@openrouter/sdk 0.10.2 → 0.12.0

package/FUNCTIONS.md

@@ -20,7 +20,7 @@ specific category of applications.
 
 ```typescript
 import { OpenRouterCore } from "@openrouter/sdk/core.js";
-import { betaResponsesSend } from "@openrouter/sdk/funcs/betaResponsesSend.js";
+import { analyticsGetUserActivity } from "@openrouter/sdk/funcs/analyticsGetUserActivity.js";
 
 // Use `OpenRouterCore` for best tree-shaking performance.
 // You can create one instance of it to use across an application.
@@ -32,14 +32,12 @@ const openRouter = new OpenRouterCore({
 });
 
 async function run() {
-  const res = await betaResponsesSend(openRouter, {
-    openResponsesRequest: {},
-  });
+  const res = await analyticsGetUserActivity(openRouter);
   if (res.ok) {
     const { value: result } = res;
     console.log(result);
   } else {
-    console.log("betaResponsesSend failed:", res.error);
+    console.log("analyticsGetUserActivity failed:", res.error);
   }
 }
 

package/README.md

@@ -44,6 +44,17 @@ yarn add @openrouter/sdk
 > CommonJS, use `await import("@openrouter/sdk")` to import and use this package.
 <!-- End SDK Installation [installation] -->
 
+## Migrating `callModel` to `@openrouter/agent`
+
+> [!IMPORTANT]
+> `callModel` and its associated types have moved to the [`@openrouter/agent`](https://www.npmjs.com/package/@openrouter/agent) package. If you are using `callModel`, tool definitions, or related types from `@openrouter/sdk`, you should migrate to `@openrouter/agent`.
+>
+> To assist with the migration, run:
+>
+> ```bash
+> npx skills add OpenRouterTeam/skills --skill openrouter-agent-migration
+> ```
+
 <!-- Start Requirements [requirements] -->
 ## Requirements
 
@@ -97,6 +108,41 @@ for await (const chunk of result) {
 
 <!-- No Custom HTTP Client [http-client] -->
 
+<!-- Start Pagination [pagination] -->
+## Pagination
+
+Some of the endpoints in this SDK support pagination. To use pagination, you
+make your SDK calls as usual, but the returned response object will also be an
+async iterable that can be consumed using the [`for await...of`][for-await-of]
+syntax.
+
+[for-await-of]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of
+
+Here's an example of one such pagination call:
+
+```typescript
+import { OpenRouter } from "@openrouter/sdk";
+
+const openRouter = new OpenRouter({
+  httpReferer: "<value>",
+  appTitle: "<value>",
+  appCategories: "<value>",
+  apiKey: process.env["OPENROUTER_API_KEY"] ?? "",
+});
+
+async function run() {
+  const result = await openRouter.guardrails.list();
+
+  for await (const page of result) {
+    console.log(page);
+  }
+}
+
+run();
+
+```
+<!-- End Pagination [pagination] -->
+
 <!-- Start Debugging [debug] -->
 ## Debugging
 

package/esm/funcs/analyticsGetUserActivity.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
  * Returns user activity data grouped by endpoint for the last 30 (completed) UTC days. [Management key](/docs/guides/overview/auth/management-api-keys) required.
  */
-export declare function analyticsGetUserActivity(client: OpenRouterCore, request?: operations.GetUserActivityRequest | undefined, options?: RequestOptions): APIPromise<Result<operations.GetUserActivityResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.ForbiddenResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function analyticsGetUserActivity(client: OpenRouterCore, request?: operations.GetUserActivityRequest | undefined, options?: RequestOptions): APIPromise<Result<models.ActivityResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.ForbiddenResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=analyticsGetUserActivity.d.ts.map

package/esm/funcs/analyticsGetUserActivity.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";
 /**
@@ -29,7 +30,9 @@ async function $do(client, request, options) {
     const body = null;
     const path = pathToFunc("/activity")();
     const query = encodeFormQuery({
+        "api_key_hash": payload?.api_key_hash,
         "date": payload?.date,
+        "user_id": payload?.user_id,
     });
     const headers = new Headers(compactMap({
         Accept: "application/json",
@@ -49,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,
@@ -69,7 +82,7 @@ async function $do(client, request, options) {
     const req = requestRes.value;
     const doResult = await client._do(req, {
         context,
-        errorCodes: ["400", "401", "403", "4XX", "500", "5XX"],
+        errorCodes: ["400", "401", "403", "404", "4XX", "500", "5XX"],
         retryConfig: context.retryConfig,
         retryCodes: context.retryCodes,
     });
@@ -80,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.GetUserActivityResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$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.ActivityResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$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/apiKeysCreate.js

@@ -47,8 +47,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,

package/esm/funcs/apiKeysDelete.js

@@ -52,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,

package/esm/funcs/apiKeysGet.js

@@ -52,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,

package/esm/funcs/apiKeysGetCurrentKeyMetadata.js

@@ -46,8 +46,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,

package/esm/funcs/apiKeysList.js

@@ -50,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,

package/esm/funcs/apiKeysUpdate.js

@@ -53,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,

package/esm/funcs/betaResponsesSend.d.ts

@@ -17,14 +17,14 @@ import { Result } from "../types/fp.js";
  * Creates a streaming or non-streaming response using OpenResponses API format
  */
 export declare function betaResponsesSend(client: OpenRouterCore, request: operations.CreateResponsesRequest & {
-    openResponsesRequest: {
+    responsesRequest: {
         stream?: false;
     };
-}, options?: RequestOptions): APIPromise<Result<models.OpenResponsesNonStreamingResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+}, options?: RequestOptions): APIPromise<Result<models.OpenResponsesResult, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 export declare function betaResponsesSend(client: OpenRouterCore, request: operations.CreateResponsesRequest & {
-    openResponsesRequest: {
+    responsesRequest: {
         stream: true;
     };
-}, options?: RequestOptions): APIPromise<Result<EventStream<models.OpenResponsesStreamEvent>, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+}, options?: RequestOptions): APIPromise<Result<EventStream<models.StreamEvents>, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 export declare function betaResponsesSend(client: OpenRouterCore, request: operations.CreateResponsesRequest, options?: RequestOptions): APIPromise<Result<operations.CreateResponsesResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=betaResponsesSend.d.ts.map

package/esm/funcs/betaResponsesSend.js

@@ -20,13 +20,11 @@ async function $do(client, request, options) {
         return [parsed, { status: "invalid" }];
     }
     const payload = parsed.value;
-    const body = encodeJSON("body", payload.OpenResponsesRequest, {
-        explode: true,
-    });
+    const body = encodeJSON("body", payload.ResponsesRequest, { explode: true });
     const path = pathToFunc("/responses")();
     const headers = new Headers(compactMap({
         "Content-Type": "application/json",
-        Accept: request?.openResponsesRequest?.stream
+        Accept: request?.responsesRequest?.stream
             ? "text/event-stream"
             : "application/json",
         "HTTP-Referer": encodeSimple("HTTP-Referer", payload["HTTP-Referer"] ?? client._options.httpReferer, { explode: false, charEncoding: "none" }),
@@ -45,8 +43,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,

package/esm/funcs/call-model.d.ts

@@ -19,7 +19,7 @@ export type { CallModelInput } from '../lib/async-params.js';
  * - `for await (const event of response.getToolStream())` - Stream tool events (incl. preliminary results)
  * - `for await (const toolCall of response.getToolCallsStream())` - Stream structured tool calls
  * - `await response.getToolCalls()` - Get all tool calls from completed response
- * - `for await (const msg of response.getNewMessagesStream())` - Stream incremental message updates
+ * - `for await (const msg of response.getNewMessagesStream())` - Stream cumulative message snapshots
  * - `for await (const event of response.getFullResponsesStream())` - Stream all events (incl. tool preliminary)
  *
  * All consumption patterns can be used concurrently on the same response.

package/esm/funcs/call-model.js

@@ -14,7 +14,7 @@ import { convertToolsToAPIFormat } from '../lib/tool-executor.js';
  * - `for await (const event of response.getToolStream())` - Stream tool events (incl. preliminary results)
  * - `for await (const toolCall of response.getToolCallsStream())` - Stream structured tool calls
  * - `await response.getToolCalls()` - Get all tool calls from completed response
- * - `for await (const msg of response.getNewMessagesStream())` - Stream incremental message updates
+ * - `for await (const msg of response.getNewMessagesStream())` - Stream cumulative message snapshots
  * - `for await (const event of response.getFullResponsesStream())` - Stream all events (incl. tool preliminary)
  *
  * All consumption patterns can be used concurrently on the same response.

package/esm/funcs/chatSend.d.ts

@@ -17,14 +17,14 @@ import { Result } from "../types/fp.js";
  * Sends a request for a model response for the given chat conversation. Supports both streaming and non-streaming modes.
  */
 export declare function chatSend(client: OpenRouterCore, request: operations.SendChatCompletionRequestRequest & {
-    chatGenerationParams: {
+    chatRequest: {
         stream?: false;
     };
-}, options?: RequestOptions): APIPromise<Result<models.ChatResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+}, options?: RequestOptions): APIPromise<Result<models.ChatResult, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 export declare function chatSend(client: OpenRouterCore, request: operations.SendChatCompletionRequestRequest & {
-    chatGenerationParams: {
+    chatRequest: {
         stream: true;
     };
-}, options?: RequestOptions): APIPromise<Result<EventStream<models.ChatStreamingResponseChunk>, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+}, options?: RequestOptions): APIPromise<Result<EventStream<models.ChatStreamChunk>, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 export declare function chatSend(client: OpenRouterCore, request: operations.SendChatCompletionRequestRequest, options?: RequestOptions): APIPromise<Result<operations.SendChatCompletionRequestResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=chatSend.d.ts.map

package/esm/funcs/chatSend.js

@@ -20,13 +20,11 @@ async function $do(client, request, options) {
         return [parsed, { status: "invalid" }];
     }
     const payload = parsed.value;
-    const body = encodeJSON("body", payload.ChatGenerationParams, {
-        explode: true,
-    });
+    const body = encodeJSON("body", payload.ChatRequest, { explode: true });
     const path = pathToFunc("/chat/completions")();
     const headers = new Headers(compactMap({
         "Content-Type": "application/json",
-        Accept: request?.chatGenerationParams?.stream
+        Accept: request?.chatRequest?.stream
             ? "text/event-stream"
             : "application/json",
         "HTTP-Referer": encodeSimple("HTTP-Referer", payload["HTTP-Referer"] ?? client._options.httpReferer, { explode: false, charEncoding: "none" }),
@@ -45,8 +43,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,

package/esm/funcs/creditsGetCredits.js

@@ -46,8 +46,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,

package/esm/funcs/embeddingsGenerate.js

@@ -47,8 +47,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,

package/esm/funcs/embeddingsListModels.js

@@ -47,8 +47,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,

package/esm/funcs/endpointsList.js

@@ -53,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,

package/esm/funcs/endpointsListZdrEndpoints.js

@@ -43,8 +43,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,

package/esm/funcs/generationsGetGeneration.js

@@ -46,8 +46,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,

package/esm/funcs/guardrailsBulkAssignKeys.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
  * Assign multiple API keys to a specific guardrail. [Management key](/docs/guides/overview/auth/management-api-keys) required.
  */
-export declare function guardrailsBulkAssignKeys(client: OpenRouterCore, request: operations.BulkAssignKeysToGuardrailRequest, options?: RequestOptions): APIPromise<Result<operations.BulkAssignKeysToGuardrailResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function guardrailsBulkAssignKeys(client: OpenRouterCore, request: operations.BulkAssignKeysToGuardrailRequest, options?: RequestOptions): APIPromise<Result<models.BulkAssignKeysResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=guardrailsBulkAssignKeys.d.ts.map

package/esm/funcs/guardrailsBulkAssignKeys.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.BulkAssignKeysRequest, {
+        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.BulkAssignKeysToGuardrailResponse$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.BulkAssignKeysResponse$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/guardrailsBulkAssignMembers.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
  * Assign multiple organization members to a specific guardrail. [Management key](/docs/guides/overview/auth/management-api-keys) required.
  */
-export declare function guardrailsBulkAssignMembers(client: OpenRouterCore, request: operations.BulkAssignMembersToGuardrailRequest, options?: RequestOptions): APIPromise<Result<operations.BulkAssignMembersToGuardrailResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function guardrailsBulkAssignMembers(client: OpenRouterCore, request: operations.BulkAssignMembersToGuardrailRequest, options?: RequestOptions): APIPromise<Result<models.BulkAssignMembersResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=guardrailsBulkAssignMembers.d.ts.map