@deeprelay/sdk 0.4.0 → 0.4.2

package/.openapi-generator/FILES

@@ -8,6 +8,7 @@ docs/AlertsApi.md
 docs/ApiKey.md
 docs/ApiKeyCreate.md
 docs/ApiKeyCreated.md
+docs/ApiKeyFallbackEntry.md
 docs/ApiKeyList.md
 docs/ApiKeyScopes.md
 docs/ApiKeyUpdate.md
@@ -51,6 +52,7 @@ docs/PeakWindow.md
 docs/Problem.md
 docs/RefereeStatus.md
 docs/Referral.md
+docs/RequestAttempt.md
 docs/RequestLogEntry.md
 docs/RequestLogPage.md
 docs/RequestsApi.md
@@ -107,6 +109,7 @@ src/models/AlertSettingsUpdate.ts
 src/models/ApiKey.ts
 src/models/ApiKeyCreate.ts
 src/models/ApiKeyCreated.ts
+src/models/ApiKeyFallbackEntry.ts
 src/models/ApiKeyList.ts
 src/models/ApiKeyScopes.ts
 src/models/ApiKeyUpdate.ts
@@ -146,6 +149,7 @@ src/models/PeakWindow.ts
 src/models/Problem.ts
 src/models/RefereeStatus.ts
 src/models/Referral.ts
+src/models/RequestAttempt.ts
 src/models/RequestLogEntry.ts
 src/models/RequestLogPage.ts
 src/models/ResponseFormatJSONObject.ts

package/README.md

@@ -1,4 +1,4 @@
-# @deeprelay/sdk@0.4.0
+# @deeprelay/sdk@0.4.2
 
 A TypeScript SDK client for the api.deeprelay.ai API.
 
@@ -99,6 +99,7 @@ All URIs are relative to *https://api.deeprelay.ai/v1*
 - [ApiKey](docs/ApiKey.md)
 - [ApiKeyCreate](docs/ApiKeyCreate.md)
 - [ApiKeyCreated](docs/ApiKeyCreated.md)
+- [ApiKeyFallbackEntry](docs/ApiKeyFallbackEntry.md)
 - [ApiKeyList](docs/ApiKeyList.md)
 - [ApiKeyScopes](docs/ApiKeyScopes.md)
 - [ApiKeyUpdate](docs/ApiKeyUpdate.md)
@@ -138,6 +139,7 @@ All URIs are relative to *https://api.deeprelay.ai/v1*
 - [Problem](docs/Problem.md)
 - [RefereeStatus](docs/RefereeStatus.md)
 - [Referral](docs/Referral.md)
+- [RequestAttempt](docs/RequestAttempt.md)
 - [RequestLogEntry](docs/RequestLogEntry.md)
 - [RequestLogPage](docs/RequestLogPage.md)
 - [ResponseFormatJSONObject](docs/ResponseFormatJSONObject.md)
@@ -192,7 +194,7 @@ and is automatically generated by the
 [OpenAPI Generator](https://openapi-generator.tech) project:
 
 - API version: `1.0.0`
-- Package version: `0.4.0`
+- Package version: `0.4.2`
 - Generator version: `7.24.0`
 - Build package: `org.openapitools.codegen.languages.TypeScriptFetchClientCodegen`
 

package/dist/apis/ApiKeysApi.d.ts

@@ -95,12 +95,12 @@ export declare class ApiKeysApi extends runtime.BaseAPI {
      */
     updateApiKeyRequestOpts(requestParameters: UpdateApiKeyRequest): Promise<runtime.RequestOpts>;
     /**
-     * Changes a key\'s name, budget, model allowlist, rate limit or expiry. An absent field is left unchanged; an explicit `null` clears `budget_cents`, `allowed_models` or `expires_at`. `scopes` cannot be changed after minting, and unknown fields are refused (422), so a typo never looks like a successful change. Requires the `keys:manage` capability (403 `keys_manage_required` otherwise); a member can only change keys they created.
+     * Changes a key\'s name, budget, model allowlist, backup models, rate limit or expiry. An absent field is left unchanged; an explicit `null` clears `budget_cents`, `allowed_models`, `fallback_models` or `expires_at`. `scopes` cannot be changed after minting, and unknown fields are refused (422), so a typo never looks like a successful change. Requires the `keys:manage` capability (403 `keys_manage_required` otherwise); a member can only change keys they created.
      * Update an API key\'s name or limits
      */
     updateApiKeyRaw(requestParameters: UpdateApiKeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiKey>>;
     /**
-     * Changes a key\'s name, budget, model allowlist, rate limit or expiry. An absent field is left unchanged; an explicit `null` clears `budget_cents`, `allowed_models` or `expires_at`. `scopes` cannot be changed after minting, and unknown fields are refused (422), so a typo never looks like a successful change. Requires the `keys:manage` capability (403 `keys_manage_required` otherwise); a member can only change keys they created.
+     * Changes a key\'s name, budget, model allowlist, backup models, rate limit or expiry. An absent field is left unchanged; an explicit `null` clears `budget_cents`, `allowed_models`, `fallback_models` or `expires_at`. `scopes` cannot be changed after minting, and unknown fields are refused (422), so a typo never looks like a successful change. Requires the `keys:manage` capability (403 `keys_manage_required` otherwise); a member can only change keys they created.
      * Update an API key\'s name or limits
      */
     updateApiKey(requestParameters: UpdateApiKeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiKey>;

package/dist/apis/ApiKeysApi.js

@@ -260,7 +260,7 @@ class ApiKeysApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Changes a key\'s name, budget, model allowlist, rate limit or expiry. An absent field is left unchanged; an explicit `null` clears `budget_cents`, `allowed_models` or `expires_at`. `scopes` cannot be changed after minting, and unknown fields are refused (422), so a typo never looks like a successful change. Requires the `keys:manage` capability (403 `keys_manage_required` otherwise); a member can only change keys they created.
+     * Changes a key\'s name, budget, model allowlist, backup models, rate limit or expiry. An absent field is left unchanged; an explicit `null` clears `budget_cents`, `allowed_models`, `fallback_models` or `expires_at`. `scopes` cannot be changed after minting, and unknown fields are refused (422), so a typo never looks like a successful change. Requires the `keys:manage` capability (403 `keys_manage_required` otherwise); a member can only change keys they created.
      * Update an API key\'s name or limits
      */
     updateApiKeyRaw(requestParameters, initOverrides) {
@@ -271,7 +271,7 @@ class ApiKeysApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Changes a key\'s name, budget, model allowlist, rate limit or expiry. An absent field is left unchanged; an explicit `null` clears `budget_cents`, `allowed_models` or `expires_at`. `scopes` cannot be changed after minting, and unknown fields are refused (422), so a typo never looks like a successful change. Requires the `keys:manage` capability (403 `keys_manage_required` otherwise); a member can only change keys they created.
+     * Changes a key\'s name, budget, model allowlist, backup models, rate limit or expiry. An absent field is left unchanged; an explicit `null` clears `budget_cents`, `allowed_models`, `fallback_models` or `expires_at`. `scopes` cannot be changed after minting, and unknown fields are refused (422), so a typo never looks like a successful change. Requires the `keys:manage` capability (403 `keys_manage_required` otherwise); a member can only change keys they created.
      * Update an API key\'s name or limits
      */
     updateApiKey(requestParameters, initOverrides) {

package/dist/apis/InferenceApi.d.ts

@@ -28,6 +28,7 @@ export interface CancelVideoRequest {
 export interface CreateChatCompletionRequest {
     chatCompletionRequest: ChatCompletionRequest;
     xClientRequestId?: string;
+    xDeeprelayFallbackModels?: string;
 }
 export interface CreateEmbeddingsRequest {
     embeddingsRequest: EmbeddingsRequest;
@@ -84,12 +85,12 @@ export declare class InferenceApi extends runtime.BaseAPI {
      */
     createChatCompletionRequestOpts(requestParameters: CreateChatCompletionRequest): Promise<runtime.RequestOpts>;
     /**
-     * OpenAI-compatible chat completion. Parameters fall into three groups:  - **Semantic parameters are gated per model.** `response_format`,   `tools`/`tool_choice`, `logprobs`/`top_logprobs` and `image_url`   content parts are sent only to a model whose `/v1/models` entry   lists the capability in `supported_parameters` (`vision` for   images). A model without it returns 400 `unsupported_parameter`   whose message names the models that do support it. When the model   supports the parameter but none of its currently routable upstreams   does, the request fails with 503 `upstream_unavailable` rather than   being silently degraded. - **Hints are forwarded or dropped, never rejected.**   `reasoning_effort`, `presence_penalty`, `frequency_penalty`, `seed`   and `parallel_tool_calls` are forwarded to an upstream that accepts   them and otherwise dropped. Every drop is reported in the   `x-deeprelay-ignored-params` response header. - **Rejected everywhere.** `logit_bias` and `function_call` return   400 `unsupported_parameter`; `input_audio` and `file` content parts   return 400 `unsupported_content_part`.  A non-strict `json_schema` sent to a model that can only guarantee JSON is served as `json_object` and reported as `response_format:downgraded`; a strict one is rejected. A `json_schema` over 64 KiB or nested deeper than 32 levels returns 400 `unsupported_parameter` (param `response_format`). An upstream rejection of a request the relay accepted returns 400 `upstream_rejected_request`. A non-chat model id returns 404 `model_not_found`. The request body is capped at 32 MiB (413 `request_too_large`).  Every successful response carries `usage.cost` and `usage.cost_details` (on a stream, only in the final usage chunk). See https://deeprelay.ai/docs/api/inference#openai-compatibility.
+     * OpenAI-compatible chat completion. Parameters fall into three groups:  - **Semantic parameters are gated per model.** `response_format`,   `tools`/`tool_choice`, `logprobs`/`top_logprobs` and `image_url`   content parts are sent only to a model whose `/v1/models` entry   lists the capability in `supported_parameters` (`vision` for   images). A model without it returns 400 `unsupported_parameter`   whose message names the models that do support it. When the model   supports the parameter but none of its currently routable upstreams   does, the request fails with 503 `upstream_unavailable` rather than   being silently degraded. - **Hints are forwarded or dropped, never rejected.**   `reasoning_effort`, `presence_penalty`, `frequency_penalty`, `seed`   and `parallel_tool_calls` are forwarded to an upstream that accepts   them and otherwise dropped. Every drop is reported in the   `x-deeprelay-ignored-params` response header. - **Rejected everywhere.** `logit_bias` and `function_call` return   400 `unsupported_parameter`; `input_audio` and `file` content parts   return 400 `unsupported_content_part`.  A non-strict `json_schema` sent to a model that can only guarantee JSON is served as `json_object` and reported as `response_format:downgraded`; a strict one is rejected. A `json_schema` over 64 KiB or nested deeper than 32 levels returns 400 `unsupported_parameter` (param `response_format`). An upstream rejection of a request the relay accepted returns 400 `upstream_rejected_request`. A non-chat model id returns 404 `model_not_found`. The request body is capped at 32 MiB (413 `request_too_large`).  Every successful response carries `usage.cost` and `usage.cost_details` (on a stream, only in the final usage chunk). See https://deeprelay.ai/docs/api/inference#openai-compatibility.  **Backup models.** When the API key has `fallback_models`, or the request sends `models` or X-Deeprelay-Fallback-Models, and every provider for the requested model fails before the first token with a temporary error (unavailable, timed out, rate limited upstream, or stalled), deeprelay tries the next backup model. It never switches after the first byte, and never on a client error, a quota or budget refusal, or a content-filter result. A backup is billed at its own price under the same billing mode as the requested model. The body `model` and X-Deeprelay-Served-Model name the model that served; X-Deeprelay-Requested-Model names the one asked for, and X-Deeprelay-Fallback-Reason says why it was passed over. If no model serves, the response is the requested model\'s own error, with X-Deeprelay-Fallback-Attempted.
      * Create a chat completion (OpenAI-compatible)
      */
     createChatCompletionRaw(requestParameters: CreateChatCompletionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ChatCompletionResponse>>;
     /**
-     * OpenAI-compatible chat completion. Parameters fall into three groups:  - **Semantic parameters are gated per model.** `response_format`,   `tools`/`tool_choice`, `logprobs`/`top_logprobs` and `image_url`   content parts are sent only to a model whose `/v1/models` entry   lists the capability in `supported_parameters` (`vision` for   images). A model without it returns 400 `unsupported_parameter`   whose message names the models that do support it. When the model   supports the parameter but none of its currently routable upstreams   does, the request fails with 503 `upstream_unavailable` rather than   being silently degraded. - **Hints are forwarded or dropped, never rejected.**   `reasoning_effort`, `presence_penalty`, `frequency_penalty`, `seed`   and `parallel_tool_calls` are forwarded to an upstream that accepts   them and otherwise dropped. Every drop is reported in the   `x-deeprelay-ignored-params` response header. - **Rejected everywhere.** `logit_bias` and `function_call` return   400 `unsupported_parameter`; `input_audio` and `file` content parts   return 400 `unsupported_content_part`.  A non-strict `json_schema` sent to a model that can only guarantee JSON is served as `json_object` and reported as `response_format:downgraded`; a strict one is rejected. A `json_schema` over 64 KiB or nested deeper than 32 levels returns 400 `unsupported_parameter` (param `response_format`). An upstream rejection of a request the relay accepted returns 400 `upstream_rejected_request`. A non-chat model id returns 404 `model_not_found`. The request body is capped at 32 MiB (413 `request_too_large`).  Every successful response carries `usage.cost` and `usage.cost_details` (on a stream, only in the final usage chunk). See https://deeprelay.ai/docs/api/inference#openai-compatibility.
+     * OpenAI-compatible chat completion. Parameters fall into three groups:  - **Semantic parameters are gated per model.** `response_format`,   `tools`/`tool_choice`, `logprobs`/`top_logprobs` and `image_url`   content parts are sent only to a model whose `/v1/models` entry   lists the capability in `supported_parameters` (`vision` for   images). A model without it returns 400 `unsupported_parameter`   whose message names the models that do support it. When the model   supports the parameter but none of its currently routable upstreams   does, the request fails with 503 `upstream_unavailable` rather than   being silently degraded. - **Hints are forwarded or dropped, never rejected.**   `reasoning_effort`, `presence_penalty`, `frequency_penalty`, `seed`   and `parallel_tool_calls` are forwarded to an upstream that accepts   them and otherwise dropped. Every drop is reported in the   `x-deeprelay-ignored-params` response header. - **Rejected everywhere.** `logit_bias` and `function_call` return   400 `unsupported_parameter`; `input_audio` and `file` content parts   return 400 `unsupported_content_part`.  A non-strict `json_schema` sent to a model that can only guarantee JSON is served as `json_object` and reported as `response_format:downgraded`; a strict one is rejected. A `json_schema` over 64 KiB or nested deeper than 32 levels returns 400 `unsupported_parameter` (param `response_format`). An upstream rejection of a request the relay accepted returns 400 `upstream_rejected_request`. A non-chat model id returns 404 `model_not_found`. The request body is capped at 32 MiB (413 `request_too_large`).  Every successful response carries `usage.cost` and `usage.cost_details` (on a stream, only in the final usage chunk). See https://deeprelay.ai/docs/api/inference#openai-compatibility.  **Backup models.** When the API key has `fallback_models`, or the request sends `models` or X-Deeprelay-Fallback-Models, and every provider for the requested model fails before the first token with a temporary error (unavailable, timed out, rate limited upstream, or stalled), deeprelay tries the next backup model. It never switches after the first byte, and never on a client error, a quota or budget refusal, or a content-filter result. A backup is billed at its own price under the same billing mode as the requested model. The body `model` and X-Deeprelay-Served-Model name the model that served; X-Deeprelay-Requested-Model names the one asked for, and X-Deeprelay-Fallback-Reason says why it was passed over. If no model serves, the response is the requested model\'s own error, with X-Deeprelay-Fallback-Attempted.
      * Create a chat completion (OpenAI-compatible)
      */
     createChatCompletion(requestParameters: CreateChatCompletionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ChatCompletionResponse>;

package/dist/apis/InferenceApi.js

@@ -100,6 +100,9 @@ class InferenceApi extends runtime.BaseAPI {
             if (requestParameters['xClientRequestId'] != null) {
                 headerParameters['X-Client-Request-Id'] = String(requestParameters['xClientRequestId']);
             }
+            if (requestParameters['xDeeprelayFallbackModels'] != null) {
+                headerParameters['X-Deeprelay-Fallback-Models'] = String(requestParameters['xDeeprelayFallbackModels']);
+            }
             if (this.configuration && this.configuration.accessToken) {
                 const token = this.configuration.accessToken;
                 const tokenString = yield token("bearerAuth", []);
@@ -118,7 +121,7 @@ class InferenceApi extends runtime.BaseAPI {
         });
     }
     /**
-     * OpenAI-compatible chat completion. Parameters fall into three groups:  - **Semantic parameters are gated per model.** `response_format`,   `tools`/`tool_choice`, `logprobs`/`top_logprobs` and `image_url`   content parts are sent only to a model whose `/v1/models` entry   lists the capability in `supported_parameters` (`vision` for   images). A model without it returns 400 `unsupported_parameter`   whose message names the models that do support it. When the model   supports the parameter but none of its currently routable upstreams   does, the request fails with 503 `upstream_unavailable` rather than   being silently degraded. - **Hints are forwarded or dropped, never rejected.**   `reasoning_effort`, `presence_penalty`, `frequency_penalty`, `seed`   and `parallel_tool_calls` are forwarded to an upstream that accepts   them and otherwise dropped. Every drop is reported in the   `x-deeprelay-ignored-params` response header. - **Rejected everywhere.** `logit_bias` and `function_call` return   400 `unsupported_parameter`; `input_audio` and `file` content parts   return 400 `unsupported_content_part`.  A non-strict `json_schema` sent to a model that can only guarantee JSON is served as `json_object` and reported as `response_format:downgraded`; a strict one is rejected. A `json_schema` over 64 KiB or nested deeper than 32 levels returns 400 `unsupported_parameter` (param `response_format`). An upstream rejection of a request the relay accepted returns 400 `upstream_rejected_request`. A non-chat model id returns 404 `model_not_found`. The request body is capped at 32 MiB (413 `request_too_large`).  Every successful response carries `usage.cost` and `usage.cost_details` (on a stream, only in the final usage chunk). See https://deeprelay.ai/docs/api/inference#openai-compatibility.
+     * OpenAI-compatible chat completion. Parameters fall into three groups:  - **Semantic parameters are gated per model.** `response_format`,   `tools`/`tool_choice`, `logprobs`/`top_logprobs` and `image_url`   content parts are sent only to a model whose `/v1/models` entry   lists the capability in `supported_parameters` (`vision` for   images). A model without it returns 400 `unsupported_parameter`   whose message names the models that do support it. When the model   supports the parameter but none of its currently routable upstreams   does, the request fails with 503 `upstream_unavailable` rather than   being silently degraded. - **Hints are forwarded or dropped, never rejected.**   `reasoning_effort`, `presence_penalty`, `frequency_penalty`, `seed`   and `parallel_tool_calls` are forwarded to an upstream that accepts   them and otherwise dropped. Every drop is reported in the   `x-deeprelay-ignored-params` response header. - **Rejected everywhere.** `logit_bias` and `function_call` return   400 `unsupported_parameter`; `input_audio` and `file` content parts   return 400 `unsupported_content_part`.  A non-strict `json_schema` sent to a model that can only guarantee JSON is served as `json_object` and reported as `response_format:downgraded`; a strict one is rejected. A `json_schema` over 64 KiB or nested deeper than 32 levels returns 400 `unsupported_parameter` (param `response_format`). An upstream rejection of a request the relay accepted returns 400 `upstream_rejected_request`. A non-chat model id returns 404 `model_not_found`. The request body is capped at 32 MiB (413 `request_too_large`).  Every successful response carries `usage.cost` and `usage.cost_details` (on a stream, only in the final usage chunk). See https://deeprelay.ai/docs/api/inference#openai-compatibility.  **Backup models.** When the API key has `fallback_models`, or the request sends `models` or X-Deeprelay-Fallback-Models, and every provider for the requested model fails before the first token with a temporary error (unavailable, timed out, rate limited upstream, or stalled), deeprelay tries the next backup model. It never switches after the first byte, and never on a client error, a quota or budget refusal, or a content-filter result. A backup is billed at its own price under the same billing mode as the requested model. The body `model` and X-Deeprelay-Served-Model name the model that served; X-Deeprelay-Requested-Model names the one asked for, and X-Deeprelay-Fallback-Reason says why it was passed over. If no model serves, the response is the requested model\'s own error, with X-Deeprelay-Fallback-Attempted.
      * Create a chat completion (OpenAI-compatible)
      */
     createChatCompletionRaw(requestParameters, initOverrides) {
@@ -129,7 +132,7 @@ class InferenceApi extends runtime.BaseAPI {
         });
     }
     /**
-     * OpenAI-compatible chat completion. Parameters fall into three groups:  - **Semantic parameters are gated per model.** `response_format`,   `tools`/`tool_choice`, `logprobs`/`top_logprobs` and `image_url`   content parts are sent only to a model whose `/v1/models` entry   lists the capability in `supported_parameters` (`vision` for   images). A model without it returns 400 `unsupported_parameter`   whose message names the models that do support it. When the model   supports the parameter but none of its currently routable upstreams   does, the request fails with 503 `upstream_unavailable` rather than   being silently degraded. - **Hints are forwarded or dropped, never rejected.**   `reasoning_effort`, `presence_penalty`, `frequency_penalty`, `seed`   and `parallel_tool_calls` are forwarded to an upstream that accepts   them and otherwise dropped. Every drop is reported in the   `x-deeprelay-ignored-params` response header. - **Rejected everywhere.** `logit_bias` and `function_call` return   400 `unsupported_parameter`; `input_audio` and `file` content parts   return 400 `unsupported_content_part`.  A non-strict `json_schema` sent to a model that can only guarantee JSON is served as `json_object` and reported as `response_format:downgraded`; a strict one is rejected. A `json_schema` over 64 KiB or nested deeper than 32 levels returns 400 `unsupported_parameter` (param `response_format`). An upstream rejection of a request the relay accepted returns 400 `upstream_rejected_request`. A non-chat model id returns 404 `model_not_found`. The request body is capped at 32 MiB (413 `request_too_large`).  Every successful response carries `usage.cost` and `usage.cost_details` (on a stream, only in the final usage chunk). See https://deeprelay.ai/docs/api/inference#openai-compatibility.
+     * OpenAI-compatible chat completion. Parameters fall into three groups:  - **Semantic parameters are gated per model.** `response_format`,   `tools`/`tool_choice`, `logprobs`/`top_logprobs` and `image_url`   content parts are sent only to a model whose `/v1/models` entry   lists the capability in `supported_parameters` (`vision` for   images). A model without it returns 400 `unsupported_parameter`   whose message names the models that do support it. When the model   supports the parameter but none of its currently routable upstreams   does, the request fails with 503 `upstream_unavailable` rather than   being silently degraded. - **Hints are forwarded or dropped, never rejected.**   `reasoning_effort`, `presence_penalty`, `frequency_penalty`, `seed`   and `parallel_tool_calls` are forwarded to an upstream that accepts   them and otherwise dropped. Every drop is reported in the   `x-deeprelay-ignored-params` response header. - **Rejected everywhere.** `logit_bias` and `function_call` return   400 `unsupported_parameter`; `input_audio` and `file` content parts   return 400 `unsupported_content_part`.  A non-strict `json_schema` sent to a model that can only guarantee JSON is served as `json_object` and reported as `response_format:downgraded`; a strict one is rejected. A `json_schema` over 64 KiB or nested deeper than 32 levels returns 400 `unsupported_parameter` (param `response_format`). An upstream rejection of a request the relay accepted returns 400 `upstream_rejected_request`. A non-chat model id returns 404 `model_not_found`. The request body is capped at 32 MiB (413 `request_too_large`).  Every successful response carries `usage.cost` and `usage.cost_details` (on a stream, only in the final usage chunk). See https://deeprelay.ai/docs/api/inference#openai-compatibility.  **Backup models.** When the API key has `fallback_models`, or the request sends `models` or X-Deeprelay-Fallback-Models, and every provider for the requested model fails before the first token with a temporary error (unavailable, timed out, rate limited upstream, or stalled), deeprelay tries the next backup model. It never switches after the first byte, and never on a client error, a quota or budget refusal, or a content-filter result. A backup is billed at its own price under the same billing mode as the requested model. The body `model` and X-Deeprelay-Served-Model name the model that served; X-Deeprelay-Requested-Model names the one asked for, and X-Deeprelay-Fallback-Reason says why it was passed over. If no model serves, the response is the requested model\'s own error, with X-Deeprelay-Fallback-Attempted.
      * Create a chat completion (OpenAI-compatible)
      */
     createChatCompletion(requestParameters, initOverrides) {

package/dist/apis/RequestsApi.d.ts

@@ -21,6 +21,7 @@ export interface ExportRequestsRequest {
     clientRequestId?: string;
     from?: Date;
     to?: Date;
+    fallback?: boolean;
 }
 export interface GetRequestRequest {
     id: string;
@@ -34,6 +35,7 @@ export interface ListRequestsRequest {
     clientRequestId?: string;
     from?: Date;
     to?: Date;
+    fallback?: boolean;
     cursor?: string;
     limit?: number;
 }
@@ -46,12 +48,12 @@ export declare class RequestsApi extends runtime.BaseAPI {
      */
     exportRequestsRequestOpts(requestParameters: ExportRequestsRequest): Promise<runtime.RequestOpts>;
     /**
-     * Streams every request-log row matching the filters as a CSV attachment, oldest columns first: `request_id, client_request_id, occurred_at, surface, model, key_id, key_name, key_prefix, status, http_status, error_code, finish_reason, prompt_tokens, completion_tokens, cached_tokens, reasoning_tokens, quota_units, cost, plan_covered, ttft_ms, duration_ms, ignored_params`. Takes the same filters and visibility rules as `GET /requests`, without the cursor and limit.  The export is counted before anything is written. When the filters match more rows than the export cap, the answer is 422 `export_too_large` and the problem body carries `max_rows`; narrow the time range or add a filter, then export again.  Requires the `serverless:read` scope. Exports have their own, tighter per-key rate limit.
+     * Streams every request-log row matching the filters as a CSV attachment, oldest columns first: `request_id, client_request_id, occurred_at, surface, model, key_id, key_name, key_prefix, status, http_status, error_code, finish_reason, prompt_tokens, completion_tokens, cached_tokens, reasoning_tokens, quota_units, cost, plan_covered, ttft_ms, duration_ms, ignored_params, requested_model, served_model, fallback_reason`. Takes the same filters and visibility rules as `GET /requests`, without the cursor and limit.  The export is counted before anything is written. When the filters match more rows than the export cap, the answer is 422 `export_too_large` and the problem body carries `max_rows`; narrow the time range or add a filter, then export again.  Requires the `serverless:read` scope. Exports have their own, tighter per-key rate limit.
      * Export the request log as CSV
      */
     exportRequestsRaw(requestParameters: ExportRequestsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>>;
     /**
-     * Streams every request-log row matching the filters as a CSV attachment, oldest columns first: `request_id, client_request_id, occurred_at, surface, model, key_id, key_name, key_prefix, status, http_status, error_code, finish_reason, prompt_tokens, completion_tokens, cached_tokens, reasoning_tokens, quota_units, cost, plan_covered, ttft_ms, duration_ms, ignored_params`. Takes the same filters and visibility rules as `GET /requests`, without the cursor and limit.  The export is counted before anything is written. When the filters match more rows than the export cap, the answer is 422 `export_too_large` and the problem body carries `max_rows`; narrow the time range or add a filter, then export again.  Requires the `serverless:read` scope. Exports have their own, tighter per-key rate limit.
+     * Streams every request-log row matching the filters as a CSV attachment, oldest columns first: `request_id, client_request_id, occurred_at, surface, model, key_id, key_name, key_prefix, status, http_status, error_code, finish_reason, prompt_tokens, completion_tokens, cached_tokens, reasoning_tokens, quota_units, cost, plan_covered, ttft_ms, duration_ms, ignored_params, requested_model, served_model, fallback_reason`. Takes the same filters and visibility rules as `GET /requests`, without the cursor and limit.  The export is counted before anything is written. When the filters match more rows than the export cap, the answer is 422 `export_too_large` and the problem body carries `max_rows`; narrow the time range or add a filter, then export again.  Requires the `serverless:read` scope. Exports have their own, tighter per-key rate limit.
      * Export the request log as CSV
      */
     exportRequests(requestParameters?: ExportRequestsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string>;

package/dist/apis/RequestsApi.js

@@ -60,6 +60,9 @@ class RequestsApi extends runtime.BaseAPI {
             if (requestParameters['to'] != null) {
                 queryParameters['to'] = requestParameters['to'].toISOString();
             }
+            if (requestParameters['fallback'] != null) {
+                queryParameters['fallback'] = requestParameters['fallback'];
+            }
             const headerParameters = {};
             if (this.configuration && this.configuration.accessToken) {
                 const token = this.configuration.accessToken;
@@ -78,7 +81,7 @@ class RequestsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Streams every request-log row matching the filters as a CSV attachment, oldest columns first: `request_id, client_request_id, occurred_at, surface, model, key_id, key_name, key_prefix, status, http_status, error_code, finish_reason, prompt_tokens, completion_tokens, cached_tokens, reasoning_tokens, quota_units, cost, plan_covered, ttft_ms, duration_ms, ignored_params`. Takes the same filters and visibility rules as `GET /requests`, without the cursor and limit.  The export is counted before anything is written. When the filters match more rows than the export cap, the answer is 422 `export_too_large` and the problem body carries `max_rows`; narrow the time range or add a filter, then export again.  Requires the `serverless:read` scope. Exports have their own, tighter per-key rate limit.
+     * Streams every request-log row matching the filters as a CSV attachment, oldest columns first: `request_id, client_request_id, occurred_at, surface, model, key_id, key_name, key_prefix, status, http_status, error_code, finish_reason, prompt_tokens, completion_tokens, cached_tokens, reasoning_tokens, quota_units, cost, plan_covered, ttft_ms, duration_ms, ignored_params, requested_model, served_model, fallback_reason`. Takes the same filters and visibility rules as `GET /requests`, without the cursor and limit.  The export is counted before anything is written. When the filters match more rows than the export cap, the answer is 422 `export_too_large` and the problem body carries `max_rows`; narrow the time range or add a filter, then export again.  Requires the `serverless:read` scope. Exports have their own, tighter per-key rate limit.
      * Export the request log as CSV
      */
     exportRequestsRaw(requestParameters, initOverrides) {
@@ -94,7 +97,7 @@ class RequestsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Streams every request-log row matching the filters as a CSV attachment, oldest columns first: `request_id, client_request_id, occurred_at, surface, model, key_id, key_name, key_prefix, status, http_status, error_code, finish_reason, prompt_tokens, completion_tokens, cached_tokens, reasoning_tokens, quota_units, cost, plan_covered, ttft_ms, duration_ms, ignored_params`. Takes the same filters and visibility rules as `GET /requests`, without the cursor and limit.  The export is counted before anything is written. When the filters match more rows than the export cap, the answer is 422 `export_too_large` and the problem body carries `max_rows`; narrow the time range or add a filter, then export again.  Requires the `serverless:read` scope. Exports have their own, tighter per-key rate limit.
+     * Streams every request-log row matching the filters as a CSV attachment, oldest columns first: `request_id, client_request_id, occurred_at, surface, model, key_id, key_name, key_prefix, status, http_status, error_code, finish_reason, prompt_tokens, completion_tokens, cached_tokens, reasoning_tokens, quota_units, cost, plan_covered, ttft_ms, duration_ms, ignored_params, requested_model, served_model, fallback_reason`. Takes the same filters and visibility rules as `GET /requests`, without the cursor and limit.  The export is counted before anything is written. When the filters match more rows than the export cap, the answer is 422 `export_too_large` and the problem body carries `max_rows`; narrow the time range or add a filter, then export again.  Requires the `serverless:read` scope. Exports have their own, tighter per-key rate limit.
      * Export the request log as CSV
      */
     exportRequests() {
@@ -181,6 +184,9 @@ class RequestsApi extends runtime.BaseAPI {
             if (requestParameters['to'] != null) {
                 queryParameters['to'] = requestParameters['to'].toISOString();
             }
+            if (requestParameters['fallback'] != null) {
+                queryParameters['fallback'] = requestParameters['fallback'];
+            }
             if (requestParameters['cursor'] != null) {
                 queryParameters['cursor'] = requestParameters['cursor'];
             }

package/dist/esm/apis/ApiKeysApi.d.ts

@@ -95,12 +95,12 @@ export declare class ApiKeysApi extends runtime.BaseAPI {
      */
     updateApiKeyRequestOpts(requestParameters: UpdateApiKeyRequest): Promise<runtime.RequestOpts>;
     /**
-     * Changes a key\'s name, budget, model allowlist, rate limit or expiry. An absent field is left unchanged; an explicit `null` clears `budget_cents`, `allowed_models` or `expires_at`. `scopes` cannot be changed after minting, and unknown fields are refused (422), so a typo never looks like a successful change. Requires the `keys:manage` capability (403 `keys_manage_required` otherwise); a member can only change keys they created.
+     * Changes a key\'s name, budget, model allowlist, backup models, rate limit or expiry. An absent field is left unchanged; an explicit `null` clears `budget_cents`, `allowed_models`, `fallback_models` or `expires_at`. `scopes` cannot be changed after minting, and unknown fields are refused (422), so a typo never looks like a successful change. Requires the `keys:manage` capability (403 `keys_manage_required` otherwise); a member can only change keys they created.
      * Update an API key\'s name or limits
      */
     updateApiKeyRaw(requestParameters: UpdateApiKeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiKey>>;
     /**
-     * Changes a key\'s name, budget, model allowlist, rate limit or expiry. An absent field is left unchanged; an explicit `null` clears `budget_cents`, `allowed_models` or `expires_at`. `scopes` cannot be changed after minting, and unknown fields are refused (422), so a typo never looks like a successful change. Requires the `keys:manage` capability (403 `keys_manage_required` otherwise); a member can only change keys they created.
+     * Changes a key\'s name, budget, model allowlist, backup models, rate limit or expiry. An absent field is left unchanged; an explicit `null` clears `budget_cents`, `allowed_models`, `fallback_models` or `expires_at`. `scopes` cannot be changed after minting, and unknown fields are refused (422), so a typo never looks like a successful change. Requires the `keys:manage` capability (403 `keys_manage_required` otherwise); a member can only change keys they created.
      * Update an API key\'s name or limits
      */
     updateApiKey(requestParameters: UpdateApiKeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiKey>;

package/dist/esm/apis/ApiKeysApi.js

@@ -257,7 +257,7 @@ export class ApiKeysApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Changes a key\'s name, budget, model allowlist, rate limit or expiry. An absent field is left unchanged; an explicit `null` clears `budget_cents`, `allowed_models` or `expires_at`. `scopes` cannot be changed after minting, and unknown fields are refused (422), so a typo never looks like a successful change. Requires the `keys:manage` capability (403 `keys_manage_required` otherwise); a member can only change keys they created.
+     * Changes a key\'s name, budget, model allowlist, backup models, rate limit or expiry. An absent field is left unchanged; an explicit `null` clears `budget_cents`, `allowed_models`, `fallback_models` or `expires_at`. `scopes` cannot be changed after minting, and unknown fields are refused (422), so a typo never looks like a successful change. Requires the `keys:manage` capability (403 `keys_manage_required` otherwise); a member can only change keys they created.
      * Update an API key\'s name or limits
      */
     updateApiKeyRaw(requestParameters, initOverrides) {
@@ -268,7 +268,7 @@ export class ApiKeysApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Changes a key\'s name, budget, model allowlist, rate limit or expiry. An absent field is left unchanged; an explicit `null` clears `budget_cents`, `allowed_models` or `expires_at`. `scopes` cannot be changed after minting, and unknown fields are refused (422), so a typo never looks like a successful change. Requires the `keys:manage` capability (403 `keys_manage_required` otherwise); a member can only change keys they created.
+     * Changes a key\'s name, budget, model allowlist, backup models, rate limit or expiry. An absent field is left unchanged; an explicit `null` clears `budget_cents`, `allowed_models`, `fallback_models` or `expires_at`. `scopes` cannot be changed after minting, and unknown fields are refused (422), so a typo never looks like a successful change. Requires the `keys:manage` capability (403 `keys_manage_required` otherwise); a member can only change keys they created.
      * Update an API key\'s name or limits
      */
     updateApiKey(requestParameters, initOverrides) {

package/dist/esm/apis/InferenceApi.d.ts

@@ -28,6 +28,7 @@ export interface CancelVideoRequest {
 export interface CreateChatCompletionRequest {
     chatCompletionRequest: ChatCompletionRequest;
     xClientRequestId?: string;
+    xDeeprelayFallbackModels?: string;
 }
 export interface CreateEmbeddingsRequest {
     embeddingsRequest: EmbeddingsRequest;
@@ -84,12 +85,12 @@ export declare class InferenceApi extends runtime.BaseAPI {
      */
     createChatCompletionRequestOpts(requestParameters: CreateChatCompletionRequest): Promise<runtime.RequestOpts>;
     /**
-     * OpenAI-compatible chat completion. Parameters fall into three groups:  - **Semantic parameters are gated per model.** `response_format`,   `tools`/`tool_choice`, `logprobs`/`top_logprobs` and `image_url`   content parts are sent only to a model whose `/v1/models` entry   lists the capability in `supported_parameters` (`vision` for   images). A model without it returns 400 `unsupported_parameter`   whose message names the models that do support it. When the model   supports the parameter but none of its currently routable upstreams   does, the request fails with 503 `upstream_unavailable` rather than   being silently degraded. - **Hints are forwarded or dropped, never rejected.**   `reasoning_effort`, `presence_penalty`, `frequency_penalty`, `seed`   and `parallel_tool_calls` are forwarded to an upstream that accepts   them and otherwise dropped. Every drop is reported in the   `x-deeprelay-ignored-params` response header. - **Rejected everywhere.** `logit_bias` and `function_call` return   400 `unsupported_parameter`; `input_audio` and `file` content parts   return 400 `unsupported_content_part`.  A non-strict `json_schema` sent to a model that can only guarantee JSON is served as `json_object` and reported as `response_format:downgraded`; a strict one is rejected. A `json_schema` over 64 KiB or nested deeper than 32 levels returns 400 `unsupported_parameter` (param `response_format`). An upstream rejection of a request the relay accepted returns 400 `upstream_rejected_request`. A non-chat model id returns 404 `model_not_found`. The request body is capped at 32 MiB (413 `request_too_large`).  Every successful response carries `usage.cost` and `usage.cost_details` (on a stream, only in the final usage chunk). See https://deeprelay.ai/docs/api/inference#openai-compatibility.
+     * OpenAI-compatible chat completion. Parameters fall into three groups:  - **Semantic parameters are gated per model.** `response_format`,   `tools`/`tool_choice`, `logprobs`/`top_logprobs` and `image_url`   content parts are sent only to a model whose `/v1/models` entry   lists the capability in `supported_parameters` (`vision` for   images). A model without it returns 400 `unsupported_parameter`   whose message names the models that do support it. When the model   supports the parameter but none of its currently routable upstreams   does, the request fails with 503 `upstream_unavailable` rather than   being silently degraded. - **Hints are forwarded or dropped, never rejected.**   `reasoning_effort`, `presence_penalty`, `frequency_penalty`, `seed`   and `parallel_tool_calls` are forwarded to an upstream that accepts   them and otherwise dropped. Every drop is reported in the   `x-deeprelay-ignored-params` response header. - **Rejected everywhere.** `logit_bias` and `function_call` return   400 `unsupported_parameter`; `input_audio` and `file` content parts   return 400 `unsupported_content_part`.  A non-strict `json_schema` sent to a model that can only guarantee JSON is served as `json_object` and reported as `response_format:downgraded`; a strict one is rejected. A `json_schema` over 64 KiB or nested deeper than 32 levels returns 400 `unsupported_parameter` (param `response_format`). An upstream rejection of a request the relay accepted returns 400 `upstream_rejected_request`. A non-chat model id returns 404 `model_not_found`. The request body is capped at 32 MiB (413 `request_too_large`).  Every successful response carries `usage.cost` and `usage.cost_details` (on a stream, only in the final usage chunk). See https://deeprelay.ai/docs/api/inference#openai-compatibility.  **Backup models.** When the API key has `fallback_models`, or the request sends `models` or X-Deeprelay-Fallback-Models, and every provider for the requested model fails before the first token with a temporary error (unavailable, timed out, rate limited upstream, or stalled), deeprelay tries the next backup model. It never switches after the first byte, and never on a client error, a quota or budget refusal, or a content-filter result. A backup is billed at its own price under the same billing mode as the requested model. The body `model` and X-Deeprelay-Served-Model name the model that served; X-Deeprelay-Requested-Model names the one asked for, and X-Deeprelay-Fallback-Reason says why it was passed over. If no model serves, the response is the requested model\'s own error, with X-Deeprelay-Fallback-Attempted.
      * Create a chat completion (OpenAI-compatible)
      */
     createChatCompletionRaw(requestParameters: CreateChatCompletionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ChatCompletionResponse>>;
     /**
-     * OpenAI-compatible chat completion. Parameters fall into three groups:  - **Semantic parameters are gated per model.** `response_format`,   `tools`/`tool_choice`, `logprobs`/`top_logprobs` and `image_url`   content parts are sent only to a model whose `/v1/models` entry   lists the capability in `supported_parameters` (`vision` for   images). A model without it returns 400 `unsupported_parameter`   whose message names the models that do support it. When the model   supports the parameter but none of its currently routable upstreams   does, the request fails with 503 `upstream_unavailable` rather than   being silently degraded. - **Hints are forwarded or dropped, never rejected.**   `reasoning_effort`, `presence_penalty`, `frequency_penalty`, `seed`   and `parallel_tool_calls` are forwarded to an upstream that accepts   them and otherwise dropped. Every drop is reported in the   `x-deeprelay-ignored-params` response header. - **Rejected everywhere.** `logit_bias` and `function_call` return   400 `unsupported_parameter`; `input_audio` and `file` content parts   return 400 `unsupported_content_part`.  A non-strict `json_schema` sent to a model that can only guarantee JSON is served as `json_object` and reported as `response_format:downgraded`; a strict one is rejected. A `json_schema` over 64 KiB or nested deeper than 32 levels returns 400 `unsupported_parameter` (param `response_format`). An upstream rejection of a request the relay accepted returns 400 `upstream_rejected_request`. A non-chat model id returns 404 `model_not_found`. The request body is capped at 32 MiB (413 `request_too_large`).  Every successful response carries `usage.cost` and `usage.cost_details` (on a stream, only in the final usage chunk). See https://deeprelay.ai/docs/api/inference#openai-compatibility.
+     * OpenAI-compatible chat completion. Parameters fall into three groups:  - **Semantic parameters are gated per model.** `response_format`,   `tools`/`tool_choice`, `logprobs`/`top_logprobs` and `image_url`   content parts are sent only to a model whose `/v1/models` entry   lists the capability in `supported_parameters` (`vision` for   images). A model without it returns 400 `unsupported_parameter`   whose message names the models that do support it. When the model   supports the parameter but none of its currently routable upstreams   does, the request fails with 503 `upstream_unavailable` rather than   being silently degraded. - **Hints are forwarded or dropped, never rejected.**   `reasoning_effort`, `presence_penalty`, `frequency_penalty`, `seed`   and `parallel_tool_calls` are forwarded to an upstream that accepts   them and otherwise dropped. Every drop is reported in the   `x-deeprelay-ignored-params` response header. - **Rejected everywhere.** `logit_bias` and `function_call` return   400 `unsupported_parameter`; `input_audio` and `file` content parts   return 400 `unsupported_content_part`.  A non-strict `json_schema` sent to a model that can only guarantee JSON is served as `json_object` and reported as `response_format:downgraded`; a strict one is rejected. A `json_schema` over 64 KiB or nested deeper than 32 levels returns 400 `unsupported_parameter` (param `response_format`). An upstream rejection of a request the relay accepted returns 400 `upstream_rejected_request`. A non-chat model id returns 404 `model_not_found`. The request body is capped at 32 MiB (413 `request_too_large`).  Every successful response carries `usage.cost` and `usage.cost_details` (on a stream, only in the final usage chunk). See https://deeprelay.ai/docs/api/inference#openai-compatibility.  **Backup models.** When the API key has `fallback_models`, or the request sends `models` or X-Deeprelay-Fallback-Models, and every provider for the requested model fails before the first token with a temporary error (unavailable, timed out, rate limited upstream, or stalled), deeprelay tries the next backup model. It never switches after the first byte, and never on a client error, a quota or budget refusal, or a content-filter result. A backup is billed at its own price under the same billing mode as the requested model. The body `model` and X-Deeprelay-Served-Model name the model that served; X-Deeprelay-Requested-Model names the one asked for, and X-Deeprelay-Fallback-Reason says why it was passed over. If no model serves, the response is the requested model\'s own error, with X-Deeprelay-Fallback-Attempted.
      * Create a chat completion (OpenAI-compatible)
      */
     createChatCompletion(requestParameters: CreateChatCompletionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ChatCompletionResponse>;

package/dist/esm/apis/InferenceApi.js

@@ -97,6 +97,9 @@ export class InferenceApi extends runtime.BaseAPI {
             if (requestParameters['xClientRequestId'] != null) {
                 headerParameters['X-Client-Request-Id'] = String(requestParameters['xClientRequestId']);
             }
+            if (requestParameters['xDeeprelayFallbackModels'] != null) {
+                headerParameters['X-Deeprelay-Fallback-Models'] = String(requestParameters['xDeeprelayFallbackModels']);
+            }
             if (this.configuration && this.configuration.accessToken) {
                 const token = this.configuration.accessToken;
                 const tokenString = yield token("bearerAuth", []);
@@ -115,7 +118,7 @@ export class InferenceApi extends runtime.BaseAPI {
         });
     }
     /**
-     * OpenAI-compatible chat completion. Parameters fall into three groups:  - **Semantic parameters are gated per model.** `response_format`,   `tools`/`tool_choice`, `logprobs`/`top_logprobs` and `image_url`   content parts are sent only to a model whose `/v1/models` entry   lists the capability in `supported_parameters` (`vision` for   images). A model without it returns 400 `unsupported_parameter`   whose message names the models that do support it. When the model   supports the parameter but none of its currently routable upstreams   does, the request fails with 503 `upstream_unavailable` rather than   being silently degraded. - **Hints are forwarded or dropped, never rejected.**   `reasoning_effort`, `presence_penalty`, `frequency_penalty`, `seed`   and `parallel_tool_calls` are forwarded to an upstream that accepts   them and otherwise dropped. Every drop is reported in the   `x-deeprelay-ignored-params` response header. - **Rejected everywhere.** `logit_bias` and `function_call` return   400 `unsupported_parameter`; `input_audio` and `file` content parts   return 400 `unsupported_content_part`.  A non-strict `json_schema` sent to a model that can only guarantee JSON is served as `json_object` and reported as `response_format:downgraded`; a strict one is rejected. A `json_schema` over 64 KiB or nested deeper than 32 levels returns 400 `unsupported_parameter` (param `response_format`). An upstream rejection of a request the relay accepted returns 400 `upstream_rejected_request`. A non-chat model id returns 404 `model_not_found`. The request body is capped at 32 MiB (413 `request_too_large`).  Every successful response carries `usage.cost` and `usage.cost_details` (on a stream, only in the final usage chunk). See https://deeprelay.ai/docs/api/inference#openai-compatibility.
+     * OpenAI-compatible chat completion. Parameters fall into three groups:  - **Semantic parameters are gated per model.** `response_format`,   `tools`/`tool_choice`, `logprobs`/`top_logprobs` and `image_url`   content parts are sent only to a model whose `/v1/models` entry   lists the capability in `supported_parameters` (`vision` for   images). A model without it returns 400 `unsupported_parameter`   whose message names the models that do support it. When the model   supports the parameter but none of its currently routable upstreams   does, the request fails with 503 `upstream_unavailable` rather than   being silently degraded. - **Hints are forwarded or dropped, never rejected.**   `reasoning_effort`, `presence_penalty`, `frequency_penalty`, `seed`   and `parallel_tool_calls` are forwarded to an upstream that accepts   them and otherwise dropped. Every drop is reported in the   `x-deeprelay-ignored-params` response header. - **Rejected everywhere.** `logit_bias` and `function_call` return   400 `unsupported_parameter`; `input_audio` and `file` content parts   return 400 `unsupported_content_part`.  A non-strict `json_schema` sent to a model that can only guarantee JSON is served as `json_object` and reported as `response_format:downgraded`; a strict one is rejected. A `json_schema` over 64 KiB or nested deeper than 32 levels returns 400 `unsupported_parameter` (param `response_format`). An upstream rejection of a request the relay accepted returns 400 `upstream_rejected_request`. A non-chat model id returns 404 `model_not_found`. The request body is capped at 32 MiB (413 `request_too_large`).  Every successful response carries `usage.cost` and `usage.cost_details` (on a stream, only in the final usage chunk). See https://deeprelay.ai/docs/api/inference#openai-compatibility.  **Backup models.** When the API key has `fallback_models`, or the request sends `models` or X-Deeprelay-Fallback-Models, and every provider for the requested model fails before the first token with a temporary error (unavailable, timed out, rate limited upstream, or stalled), deeprelay tries the next backup model. It never switches after the first byte, and never on a client error, a quota or budget refusal, or a content-filter result. A backup is billed at its own price under the same billing mode as the requested model. The body `model` and X-Deeprelay-Served-Model name the model that served; X-Deeprelay-Requested-Model names the one asked for, and X-Deeprelay-Fallback-Reason says why it was passed over. If no model serves, the response is the requested model\'s own error, with X-Deeprelay-Fallback-Attempted.
      * Create a chat completion (OpenAI-compatible)
      */
     createChatCompletionRaw(requestParameters, initOverrides) {
@@ -126,7 +129,7 @@ export class InferenceApi extends runtime.BaseAPI {
         });
     }
     /**
-     * OpenAI-compatible chat completion. Parameters fall into three groups:  - **Semantic parameters are gated per model.** `response_format`,   `tools`/`tool_choice`, `logprobs`/`top_logprobs` and `image_url`   content parts are sent only to a model whose `/v1/models` entry   lists the capability in `supported_parameters` (`vision` for   images). A model without it returns 400 `unsupported_parameter`   whose message names the models that do support it. When the model   supports the parameter but none of its currently routable upstreams   does, the request fails with 503 `upstream_unavailable` rather than   being silently degraded. - **Hints are forwarded or dropped, never rejected.**   `reasoning_effort`, `presence_penalty`, `frequency_penalty`, `seed`   and `parallel_tool_calls` are forwarded to an upstream that accepts   them and otherwise dropped. Every drop is reported in the   `x-deeprelay-ignored-params` response header. - **Rejected everywhere.** `logit_bias` and `function_call` return   400 `unsupported_parameter`; `input_audio` and `file` content parts   return 400 `unsupported_content_part`.  A non-strict `json_schema` sent to a model that can only guarantee JSON is served as `json_object` and reported as `response_format:downgraded`; a strict one is rejected. A `json_schema` over 64 KiB or nested deeper than 32 levels returns 400 `unsupported_parameter` (param `response_format`). An upstream rejection of a request the relay accepted returns 400 `upstream_rejected_request`. A non-chat model id returns 404 `model_not_found`. The request body is capped at 32 MiB (413 `request_too_large`).  Every successful response carries `usage.cost` and `usage.cost_details` (on a stream, only in the final usage chunk). See https://deeprelay.ai/docs/api/inference#openai-compatibility.
+     * OpenAI-compatible chat completion. Parameters fall into three groups:  - **Semantic parameters are gated per model.** `response_format`,   `tools`/`tool_choice`, `logprobs`/`top_logprobs` and `image_url`   content parts are sent only to a model whose `/v1/models` entry   lists the capability in `supported_parameters` (`vision` for   images). A model without it returns 400 `unsupported_parameter`   whose message names the models that do support it. When the model   supports the parameter but none of its currently routable upstreams   does, the request fails with 503 `upstream_unavailable` rather than   being silently degraded. - **Hints are forwarded or dropped, never rejected.**   `reasoning_effort`, `presence_penalty`, `frequency_penalty`, `seed`   and `parallel_tool_calls` are forwarded to an upstream that accepts   them and otherwise dropped. Every drop is reported in the   `x-deeprelay-ignored-params` response header. - **Rejected everywhere.** `logit_bias` and `function_call` return   400 `unsupported_parameter`; `input_audio` and `file` content parts   return 400 `unsupported_content_part`.  A non-strict `json_schema` sent to a model that can only guarantee JSON is served as `json_object` and reported as `response_format:downgraded`; a strict one is rejected. A `json_schema` over 64 KiB or nested deeper than 32 levels returns 400 `unsupported_parameter` (param `response_format`). An upstream rejection of a request the relay accepted returns 400 `upstream_rejected_request`. A non-chat model id returns 404 `model_not_found`. The request body is capped at 32 MiB (413 `request_too_large`).  Every successful response carries `usage.cost` and `usage.cost_details` (on a stream, only in the final usage chunk). See https://deeprelay.ai/docs/api/inference#openai-compatibility.  **Backup models.** When the API key has `fallback_models`, or the request sends `models` or X-Deeprelay-Fallback-Models, and every provider for the requested model fails before the first token with a temporary error (unavailable, timed out, rate limited upstream, or stalled), deeprelay tries the next backup model. It never switches after the first byte, and never on a client error, a quota or budget refusal, or a content-filter result. A backup is billed at its own price under the same billing mode as the requested model. The body `model` and X-Deeprelay-Served-Model name the model that served; X-Deeprelay-Requested-Model names the one asked for, and X-Deeprelay-Fallback-Reason says why it was passed over. If no model serves, the response is the requested model\'s own error, with X-Deeprelay-Fallback-Attempted.
      * Create a chat completion (OpenAI-compatible)
      */
     createChatCompletion(requestParameters, initOverrides) {

package/dist/esm/apis/RequestsApi.d.ts

@@ -21,6 +21,7 @@ export interface ExportRequestsRequest {
     clientRequestId?: string;
     from?: Date;
     to?: Date;
+    fallback?: boolean;
 }
 export interface GetRequestRequest {
     id: string;
@@ -34,6 +35,7 @@ export interface ListRequestsRequest {
     clientRequestId?: string;
     from?: Date;
     to?: Date;
+    fallback?: boolean;
     cursor?: string;
     limit?: number;
 }
@@ -46,12 +48,12 @@ export declare class RequestsApi extends runtime.BaseAPI {
      */
     exportRequestsRequestOpts(requestParameters: ExportRequestsRequest): Promise<runtime.RequestOpts>;
     /**
-     * Streams every request-log row matching the filters as a CSV attachment, oldest columns first: `request_id, client_request_id, occurred_at, surface, model, key_id, key_name, key_prefix, status, http_status, error_code, finish_reason, prompt_tokens, completion_tokens, cached_tokens, reasoning_tokens, quota_units, cost, plan_covered, ttft_ms, duration_ms, ignored_params`. Takes the same filters and visibility rules as `GET /requests`, without the cursor and limit.  The export is counted before anything is written. When the filters match more rows than the export cap, the answer is 422 `export_too_large` and the problem body carries `max_rows`; narrow the time range or add a filter, then export again.  Requires the `serverless:read` scope. Exports have their own, tighter per-key rate limit.
+     * Streams every request-log row matching the filters as a CSV attachment, oldest columns first: `request_id, client_request_id, occurred_at, surface, model, key_id, key_name, key_prefix, status, http_status, error_code, finish_reason, prompt_tokens, completion_tokens, cached_tokens, reasoning_tokens, quota_units, cost, plan_covered, ttft_ms, duration_ms, ignored_params, requested_model, served_model, fallback_reason`. Takes the same filters and visibility rules as `GET /requests`, without the cursor and limit.  The export is counted before anything is written. When the filters match more rows than the export cap, the answer is 422 `export_too_large` and the problem body carries `max_rows`; narrow the time range or add a filter, then export again.  Requires the `serverless:read` scope. Exports have their own, tighter per-key rate limit.
      * Export the request log as CSV
      */
     exportRequestsRaw(requestParameters: ExportRequestsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>>;
     /**
-     * Streams every request-log row matching the filters as a CSV attachment, oldest columns first: `request_id, client_request_id, occurred_at, surface, model, key_id, key_name, key_prefix, status, http_status, error_code, finish_reason, prompt_tokens, completion_tokens, cached_tokens, reasoning_tokens, quota_units, cost, plan_covered, ttft_ms, duration_ms, ignored_params`. Takes the same filters and visibility rules as `GET /requests`, without the cursor and limit.  The export is counted before anything is written. When the filters match more rows than the export cap, the answer is 422 `export_too_large` and the problem body carries `max_rows`; narrow the time range or add a filter, then export again.  Requires the `serverless:read` scope. Exports have their own, tighter per-key rate limit.
+     * Streams every request-log row matching the filters as a CSV attachment, oldest columns first: `request_id, client_request_id, occurred_at, surface, model, key_id, key_name, key_prefix, status, http_status, error_code, finish_reason, prompt_tokens, completion_tokens, cached_tokens, reasoning_tokens, quota_units, cost, plan_covered, ttft_ms, duration_ms, ignored_params, requested_model, served_model, fallback_reason`. Takes the same filters and visibility rules as `GET /requests`, without the cursor and limit.  The export is counted before anything is written. When the filters match more rows than the export cap, the answer is 422 `export_too_large` and the problem body carries `max_rows`; narrow the time range or add a filter, then export again.  Requires the `serverless:read` scope. Exports have their own, tighter per-key rate limit.
      * Export the request log as CSV
      */
     exportRequests(requestParameters?: ExportRequestsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string>;

package/dist/esm/apis/RequestsApi.js

@@ -57,6 +57,9 @@ export class RequestsApi extends runtime.BaseAPI {
             if (requestParameters['to'] != null) {
                 queryParameters['to'] = requestParameters['to'].toISOString();
             }
+            if (requestParameters['fallback'] != null) {
+                queryParameters['fallback'] = requestParameters['fallback'];
+            }
             const headerParameters = {};
             if (this.configuration && this.configuration.accessToken) {
                 const token = this.configuration.accessToken;
@@ -75,7 +78,7 @@ export class RequestsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Streams every request-log row matching the filters as a CSV attachment, oldest columns first: `request_id, client_request_id, occurred_at, surface, model, key_id, key_name, key_prefix, status, http_status, error_code, finish_reason, prompt_tokens, completion_tokens, cached_tokens, reasoning_tokens, quota_units, cost, plan_covered, ttft_ms, duration_ms, ignored_params`. Takes the same filters and visibility rules as `GET /requests`, without the cursor and limit.  The export is counted before anything is written. When the filters match more rows than the export cap, the answer is 422 `export_too_large` and the problem body carries `max_rows`; narrow the time range or add a filter, then export again.  Requires the `serverless:read` scope. Exports have their own, tighter per-key rate limit.
+     * Streams every request-log row matching the filters as a CSV attachment, oldest columns first: `request_id, client_request_id, occurred_at, surface, model, key_id, key_name, key_prefix, status, http_status, error_code, finish_reason, prompt_tokens, completion_tokens, cached_tokens, reasoning_tokens, quota_units, cost, plan_covered, ttft_ms, duration_ms, ignored_params, requested_model, served_model, fallback_reason`. Takes the same filters and visibility rules as `GET /requests`, without the cursor and limit.  The export is counted before anything is written. When the filters match more rows than the export cap, the answer is 422 `export_too_large` and the problem body carries `max_rows`; narrow the time range or add a filter, then export again.  Requires the `serverless:read` scope. Exports have their own, tighter per-key rate limit.
      * Export the request log as CSV
      */
     exportRequestsRaw(requestParameters, initOverrides) {
@@ -91,7 +94,7 @@ export class RequestsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Streams every request-log row matching the filters as a CSV attachment, oldest columns first: `request_id, client_request_id, occurred_at, surface, model, key_id, key_name, key_prefix, status, http_status, error_code, finish_reason, prompt_tokens, completion_tokens, cached_tokens, reasoning_tokens, quota_units, cost, plan_covered, ttft_ms, duration_ms, ignored_params`. Takes the same filters and visibility rules as `GET /requests`, without the cursor and limit.  The export is counted before anything is written. When the filters match more rows than the export cap, the answer is 422 `export_too_large` and the problem body carries `max_rows`; narrow the time range or add a filter, then export again.  Requires the `serverless:read` scope. Exports have their own, tighter per-key rate limit.
+     * Streams every request-log row matching the filters as a CSV attachment, oldest columns first: `request_id, client_request_id, occurred_at, surface, model, key_id, key_name, key_prefix, status, http_status, error_code, finish_reason, prompt_tokens, completion_tokens, cached_tokens, reasoning_tokens, quota_units, cost, plan_covered, ttft_ms, duration_ms, ignored_params, requested_model, served_model, fallback_reason`. Takes the same filters and visibility rules as `GET /requests`, without the cursor and limit.  The export is counted before anything is written. When the filters match more rows than the export cap, the answer is 422 `export_too_large` and the problem body carries `max_rows`; narrow the time range or add a filter, then export again.  Requires the `serverless:read` scope. Exports have their own, tighter per-key rate limit.
      * Export the request log as CSV
      */
     exportRequests() {
@@ -178,6 +181,9 @@ export class RequestsApi extends runtime.BaseAPI {
             if (requestParameters['to'] != null) {
                 queryParameters['to'] = requestParameters['to'].toISOString();
             }
+            if (requestParameters['fallback'] != null) {
+                queryParameters['fallback'] = requestParameters['fallback'];
+            }
             if (requestParameters['cursor'] != null) {
                 queryParameters['cursor'] = requestParameters['cursor'];
             }

package/dist/esm/models/ApiKey.d.ts

@@ -10,6 +10,7 @@
  * Do not edit the class manually.
  */
 import type { ApiKeyScopes } from './ApiKeyScopes';
+import type { ApiKeyFallbackEntry } from './ApiKeyFallbackEntry';
 /**
  * An API key's metadata and limits. Never carries the secret.
  * @export
@@ -76,6 +77,24 @@ export interface ApiKey {
      * @memberof ApiKey
      */
     staleModels?: Array<string>;
+    /**
+     * Backup models in priority order, applied to every model this key calls. Null means model fallback is off (the default). If every provider for the requested model fails before the first token with a temporary error, the next entry is tried. Entries are kept when a model leaves the plan roster or the catalog and are skipped at request time; see `fallback_entries`. Not applied to Liquid.
+     * @type {Array<string>}
+     * @memberof ApiKey
+     */
+    fallbackModels: Array<string> | null;
+    /**
+     * Present when `fallback_models` is set: one entry per backup, in order, explaining it as of now.
+     * @type {Array<ApiKeyFallbackEntry>}
+     * @memberof ApiKey
+     */
+    fallbackEntries?: Array<ApiKeyFallbackEntry>;
+    /**
+     * The model this key requested most over the last 30 days, which `above_primary` is measured against. Present only for a key with `fallback_models` and recent usage.
+     * @type {string}
+     * @memberof ApiKey
+     */
+    primaryModel?: string;
     /**
      *
      * @type {number}

package/dist/esm/models/ApiKey.js

@@ -12,6 +12,7 @@
  * Do not edit the class manually.
  */
 import { ApiKeyScopesFromJSON, ApiKeyScopesToJSON, } from './ApiKeyScopes';
+import { ApiKeyFallbackEntryFromJSON, ApiKeyFallbackEntryToJSON, } from './ApiKeyFallbackEntry';
 /**
  * Check if a given object implements the ApiKey interface.
  */
@@ -30,6 +31,8 @@ export function instanceOfApiKey(value) {
         return false;
     if ((!('allowedModels' in value) && !('allowed_models' in value)) || (value['allowedModels'] === undefined && value['allowed_models'] === undefined))
         return false;
+    if ((!('fallbackModels' in value) && !('fallback_models' in value)) || (value['fallbackModels'] === undefined && value['fallback_models'] === undefined))
+        return false;
     if ((!('rateLimitRps' in value) && !('rate_limit_rps' in value)) || (value['rateLimitRps'] === undefined && value['rate_limit_rps'] === undefined))
         return false;
     if ((!('rateLimitBurst' in value) && !('rate_limit_burst' in value)) || (value['rateLimitBurst'] === undefined && value['rate_limit_burst'] === undefined))
@@ -60,6 +63,9 @@ export function ApiKeyFromJSONTyped(json, ignoreDiscriminator) {
         'budgetResetsAt': json['budget_resets_at'] == null ? undefined : (new Date(json['budget_resets_at'])),
         'allowedModels': json['allowed_models'] == null ? null : json['allowed_models'],
         'staleModels': json['stale_models'] == null ? undefined : json['stale_models'],
+        'fallbackModels': json['fallback_models'] == null ? null : json['fallback_models'],
+        'fallbackEntries': json['fallback_entries'] == null ? undefined : (json['fallback_entries'].map(ApiKeyFallbackEntryFromJSON)),
+        'primaryModel': json['primary_model'] == null ? undefined : json['primary_model'],
         'rateLimitRps': json['rate_limit_rps'],
         'rateLimitBurst': json['rate_limit_burst'],
         'expiresAt': (json['expires_at'] == null ? null : new Date(json['expires_at'])),
@@ -86,6 +92,9 @@ export function ApiKeyToJSONTyped(value, ignoreDiscriminator = false) {
         'budget_resets_at': value['budgetResetsAt'] == null ? value['budgetResetsAt'] : value['budgetResetsAt'].toISOString(),
         'allowed_models': value['allowedModels'],
         'stale_models': value['staleModels'],
+        'fallback_models': value['fallbackModels'],
+        'fallback_entries': value['fallbackEntries'] == null ? undefined : (value['fallbackEntries'].map(ApiKeyFallbackEntryToJSON)),
+        'primary_model': value['primaryModel'],
         'rate_limit_rps': value['rateLimitRps'],
         'rate_limit_burst': value['rateLimitBurst'],
         'expires_at': value['expiresAt'] == null ? value['expiresAt'] : value['expiresAt'].toISOString(),

package/dist/esm/models/ApiKeyCreate.d.ts

@@ -41,6 +41,12 @@ export interface ApiKeyCreate {
      * @memberof ApiKeyCreate
      */
     allowedModels?: Array<string>;
+    /**
+     * Backup models in priority order. Omit it to leave model fallback off. Each entry must be a chat model in the catalog and, when the key has `allowed_models`, on that list. Duplicates are removed. An empty array, more than 3 models or an invalid entry is a 422 `validation_failed` naming the `fallback_models` field.
+     * @type {Array<string>}
+     * @memberof ApiKeyCreate
+     */
+    fallbackModels?: Array<string>;
     /**
      *
      * @type {number}

package/dist/esm/models/ApiKeyCreate.js

@@ -33,6 +33,7 @@ export function ApiKeyCreateFromJSONTyped(json, ignoreDiscriminator) {
         'scopes': json['scopes'],
         'budgetCents': json['budget_cents'] == null ? undefined : json['budget_cents'],
         'allowedModels': json['allowed_models'] == null ? undefined : json['allowed_models'],
+        'fallbackModels': json['fallback_models'] == null ? undefined : json['fallback_models'],
         'rateLimitRps': json['rate_limit_rps'] == null ? undefined : json['rate_limit_rps'],
         'rateLimitBurst': json['rate_limit_burst'] == null ? undefined : json['rate_limit_burst'],
         'expiresAt': json['expires_at'] == null ? undefined : (new Date(json['expires_at'])),
@@ -50,6 +51,7 @@ export function ApiKeyCreateToJSONTyped(value, ignoreDiscriminator = false) {
         'scopes': value['scopes'],
         'budget_cents': value['budgetCents'],
         'allowed_models': value['allowedModels'],
+        'fallback_models': value['fallbackModels'],
         'rate_limit_rps': value['rateLimitRps'],
         'rate_limit_burst': value['rateLimitBurst'],
         'expires_at': value['expiresAt'] == null ? value['expiresAt'] : value['expiresAt'].toISOString(),

package/dist/esm/models/ApiKeyCreated.d.ts

@@ -10,6 +10,7 @@
  * Do not edit the class manually.
  */
 import type { ApiKeyScopes } from './ApiKeyScopes';
+import type { ApiKeyFallbackEntry } from './ApiKeyFallbackEntry';
 /**
  * The new key's metadata plus its secret (`key`), returned exactly once. The same fields as `ApiKey`, plus `key`.
  * @export
@@ -76,6 +77,24 @@ export interface ApiKeyCreated {
      * @memberof ApiKeyCreated
      */
     staleModels?: Array<string>;
+    /**
+     * Backup models in priority order, applied to every model this key calls. Null means model fallback is off (the default). If every provider for the requested model fails before the first token with a temporary error, the next entry is tried. Entries are kept when a model leaves the plan roster or the catalog and are skipped at request time; see `fallback_entries`. Not applied to Liquid.
+     * @type {Array<string>}
+     * @memberof ApiKeyCreated
+     */
+    fallbackModels: Array<string> | null;
+    /**
+     * Present when `fallback_models` is set: one entry per backup, in order, explaining it as of now.
+     * @type {Array<ApiKeyFallbackEntry>}
+     * @memberof ApiKeyCreated
+     */
+    fallbackEntries?: Array<ApiKeyFallbackEntry>;
+    /**
+     * The model this key requested most over the last 30 days, which `above_primary` is measured against. Present only for a key with `fallback_models` and recent usage.
+     * @type {string}
+     * @memberof ApiKeyCreated
+     */
+    primaryModel?: string;
     /**
      *
      * @type {number}