@deeprelay/sdk 0.2.0 → 0.3.0

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

@@ -1,6 +1,6 @@
 /**
  * deeprelay Public Developer API
- * Programmatic API for deeprelay. Authenticate with API keys minted from the dashboard. See https://deeprelay.ai/docs for details.
+ * Programmatic API for deeprelay. Authenticate with API keys minted from the dashboard. See https://deeprelay.ai/docs for details.  Keys minted from the dashboard or `deeprelay login` belong to the Production server, https://api.deeprelay.ai/v1. The Demo server is an internal staging environment with its own key store.  Versioning: `/v1` is the API version. `info.version` is the revision of this `/v1` document, not a separate API.  OpenAI compatibility: chat completions follow the OpenAI request and response shapes, but not every OpenAI parameter is carried. Some are rejected with 400 `unsupported_parameter` and any parameter not declared in this spec is accepted and ignored. The full table is at https://deeprelay.ai/docs/api/inference#openai-compatibility.
  *
  * The version of the OpenAPI document: 1.0.0
  * Contact: support@deeprelay.ai
@@ -27,17 +27,21 @@ export interface CancelVideoRequest {
 }
 export interface CreateChatCompletionRequest {
     chatCompletionRequest: ChatCompletionRequest;
+    xClientRequestId?: string;
 }
 export interface CreateEmbeddingsRequest {
     embeddingsRequest: EmbeddingsRequest;
+    xClientRequestId?: string;
 }
 export interface CreateImageRequest {
     imagesGenerationsRequest: ImagesGenerationsRequest;
     idempotencyKey?: string;
+    xClientRequestId?: string;
 }
 export interface CreateVideoRequest {
     videoCreateRequest: VideoCreateRequest;
     idempotencyKey?: string;
+    xClientRequestId?: string;
 }
 export interface GetModelRequest {
     id: string;
@@ -53,6 +57,7 @@ export interface InferencePreflightRequest {
 }
 export interface ListModelsRequest {
     modality?: ListModelsModalityEnum;
+    ifNoneMatch?: string;
 }
 export interface ListVideosRequest {
     after?: string;
@@ -79,10 +84,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.
      * 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.
      * Create a chat completion (OpenAI-compatible)
      */
     createChatCompletion(requestParameters: CreateChatCompletionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ChatCompletionResponse>;
@@ -133,10 +140,12 @@ export declare class InferenceApi extends runtime.BaseAPI {
      */
     getModelRequestOpts(requestParameters: GetModelRequest): Promise<runtime.RequestOpts>;
     /**
+     * A key with a model allowlist gets 403 `model_not_allowed_for_key` for a model off its list, and the same 403 for an id that does not exist.
      * Get a specific model (OpenAI-compatible)
      */
     getModelRaw(requestParameters: GetModelRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Model>>;
     /**
+     * A key with a model allowlist gets 403 `model_not_allowed_for_key` for a model off its list, and the same 403 for an id that does not exist.
      * Get a specific model (OpenAI-compatible)
      */
     getModel(requestParameters: GetModelRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Model>;
@@ -185,10 +194,12 @@ export declare class InferenceApi extends runtime.BaseAPI {
      */
     listModelsRequestOpts(requestParameters: ListModelsRequest): Promise<runtime.RequestOpts>;
     /**
+     * Works with or without an API key, and returns the same body either way. Without a key the response is publicly cacheable (`Cache-Control: public, max-age=60`), carries a strong `ETag` (send `If-None-Match` to get a 304), and is rate-limited per client IP (429 `rate_limit_exceeded` with Retry-After). With a key it is `Cache-Control: private` and counts against the key\'s rate limit; an invalid key returns 401, it does not fall back to anonymous access. Error responses are `no-store`.  Each entry\'s `supported_parameters` is backed by live capability probes of the model\'s upstreams: it is the list to check before sending a gated parameter (`response_format`, `structured_outputs`, `logprobs`, `tools`, `vision`, ...).  One exception to \"the same body\": a key with a model allowlist (`allowed_models`) sees only the models on its list.  Each entry may carry a `metrics` object (always the last key): measured time to first token, decode rate and success rate over a rolling window of deeprelay customer traffic. Below the sample minimum `insufficient_data` is true and the figure is omitted, never zero.
      * List available models (OpenAI-compatible)
      */
     listModelsRaw(requestParameters: ListModelsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ModelList>>;
     /**
+     * Works with or without an API key, and returns the same body either way. Without a key the response is publicly cacheable (`Cache-Control: public, max-age=60`), carries a strong `ETag` (send `If-None-Match` to get a 304), and is rate-limited per client IP (429 `rate_limit_exceeded` with Retry-After). With a key it is `Cache-Control: private` and counts against the key\'s rate limit; an invalid key returns 401, it does not fall back to anonymous access. Error responses are `no-store`.  Each entry\'s `supported_parameters` is backed by live capability probes of the model\'s upstreams: it is the list to check before sending a gated parameter (`response_format`, `structured_outputs`, `logprobs`, `tools`, `vision`, ...).  One exception to \"the same body\": a key with a model allowlist (`allowed_models`) sees only the models on its list.  Each entry may carry a `metrics` object (always the last key): measured time to first token, decode rate and success rate over a rolling window of deeprelay customer traffic. Below the sample minimum `insufficient_data` is true and the figure is omitted, never zero.
      * List available models (OpenAI-compatible)
      */
     listModels(requestParameters?: ListModelsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ModelList>;

package/dist/esm/apis/InferenceApi.js

@@ -2,7 +2,7 @@
 /* eslint-disable */
 /**
  * deeprelay Public Developer API
- * Programmatic API for deeprelay. Authenticate with API keys minted from the dashboard. See https://deeprelay.ai/docs for details.
+ * Programmatic API for deeprelay. Authenticate with API keys minted from the dashboard. See https://deeprelay.ai/docs for details.  Keys minted from the dashboard or `deeprelay login` belong to the Production server, https://api.deeprelay.ai/v1. The Demo server is an internal staging environment with its own key store.  Versioning: `/v1` is the API version. `info.version` is the revision of this `/v1` document, not a separate API.  OpenAI compatibility: chat completions follow the OpenAI request and response shapes, but not every OpenAI parameter is carried. Some are rejected with 400 `unsupported_parameter` and any parameter not declared in this spec is accepted and ignored. The full table is at https://deeprelay.ai/docs/api/inference#openai-compatibility.
  *
  * The version of the OpenAPI document: 1.0.0
  * Contact: support@deeprelay.ai
@@ -94,6 +94,9 @@ export class InferenceApi extends runtime.BaseAPI {
             const queryParameters = {};
             const headerParameters = {};
             headerParameters['Content-Type'] = 'application/json';
+            if (requestParameters['xClientRequestId'] != null) {
+                headerParameters['X-Client-Request-Id'] = String(requestParameters['xClientRequestId']);
+            }
             if (this.configuration && this.configuration.accessToken) {
                 const token = this.configuration.accessToken;
                 const tokenString = yield token("bearerAuth", []);
@@ -112,6 +115,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.
      * Create a chat completion (OpenAI-compatible)
      */
     createChatCompletionRaw(requestParameters, initOverrides) {
@@ -122,6 +126,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.
      * Create a chat completion (OpenAI-compatible)
      */
     createChatCompletion(requestParameters, initOverrides) {
@@ -141,6 +146,9 @@ export class InferenceApi extends runtime.BaseAPI {
             const queryParameters = {};
             const headerParameters = {};
             headerParameters['Content-Type'] = 'application/json';
+            if (requestParameters['xClientRequestId'] != null) {
+                headerParameters['X-Client-Request-Id'] = String(requestParameters['xClientRequestId']);
+            }
             if (this.configuration && this.configuration.accessToken) {
                 const token = this.configuration.accessToken;
                 const tokenString = yield token("bearerAuth", []);
@@ -193,6 +201,9 @@ export class InferenceApi extends runtime.BaseAPI {
             if (requestParameters['idempotencyKey'] != null) {
                 headerParameters['Idempotency-Key'] = String(requestParameters['idempotencyKey']);
             }
+            if (requestParameters['xClientRequestId'] != null) {
+                headerParameters['X-Client-Request-Id'] = String(requestParameters['xClientRequestId']);
+            }
             if (this.configuration && this.configuration.accessToken) {
                 const token = this.configuration.accessToken;
                 const tokenString = yield token("bearerAuth", []);
@@ -245,6 +256,9 @@ export class InferenceApi extends runtime.BaseAPI {
             if (requestParameters['idempotencyKey'] != null) {
                 headerParameters['Idempotency-Key'] = String(requestParameters['idempotencyKey']);
             }
+            if (requestParameters['xClientRequestId'] != null) {
+                headerParameters['X-Client-Request-Id'] = String(requestParameters['xClientRequestId']);
+            }
             if (this.configuration && this.configuration.accessToken) {
                 const token = this.configuration.accessToken;
                 const tokenString = yield token("bearerAuth", []);
@@ -311,6 +325,7 @@ export class InferenceApi extends runtime.BaseAPI {
         });
     }
     /**
+     * A key with a model allowlist gets 403 `model_not_allowed_for_key` for a model off its list, and the same 403 for an id that does not exist.
      * Get a specific model (OpenAI-compatible)
      */
     getModelRaw(requestParameters, initOverrides) {
@@ -321,6 +336,7 @@ export class InferenceApi extends runtime.BaseAPI {
         });
     }
     /**
+     * A key with a model allowlist gets 403 `model_not_allowed_for_key` for a model off its list, and the same 403 for an id that does not exist.
      * Get a specific model (OpenAI-compatible)
      */
     getModel(requestParameters, initOverrides) {
@@ -483,6 +499,9 @@ export class InferenceApi extends runtime.BaseAPI {
                 queryParameters['modality'] = requestParameters['modality'];
             }
             const headerParameters = {};
+            if (requestParameters['ifNoneMatch'] != null) {
+                headerParameters['If-None-Match'] = String(requestParameters['ifNoneMatch']);
+            }
             if (this.configuration && this.configuration.accessToken) {
                 const token = this.configuration.accessToken;
                 const tokenString = yield token("bearerAuth", []);
@@ -500,6 +519,7 @@ export class InferenceApi extends runtime.BaseAPI {
         });
     }
     /**
+     * Works with or without an API key, and returns the same body either way. Without a key the response is publicly cacheable (`Cache-Control: public, max-age=60`), carries a strong `ETag` (send `If-None-Match` to get a 304), and is rate-limited per client IP (429 `rate_limit_exceeded` with Retry-After). With a key it is `Cache-Control: private` and counts against the key\'s rate limit; an invalid key returns 401, it does not fall back to anonymous access. Error responses are `no-store`.  Each entry\'s `supported_parameters` is backed by live capability probes of the model\'s upstreams: it is the list to check before sending a gated parameter (`response_format`, `structured_outputs`, `logprobs`, `tools`, `vision`, ...).  One exception to \"the same body\": a key with a model allowlist (`allowed_models`) sees only the models on its list.  Each entry may carry a `metrics` object (always the last key): measured time to first token, decode rate and success rate over a rolling window of deeprelay customer traffic. Below the sample minimum `insufficient_data` is true and the figure is omitted, never zero.
      * List available models (OpenAI-compatible)
      */
     listModelsRaw(requestParameters, initOverrides) {
@@ -510,6 +530,7 @@ export class InferenceApi extends runtime.BaseAPI {
         });
     }
     /**
+     * Works with or without an API key, and returns the same body either way. Without a key the response is publicly cacheable (`Cache-Control: public, max-age=60`), carries a strong `ETag` (send `If-None-Match` to get a 304), and is rate-limited per client IP (429 `rate_limit_exceeded` with Retry-After). With a key it is `Cache-Control: private` and counts against the key\'s rate limit; an invalid key returns 401, it does not fall back to anonymous access. Error responses are `no-store`.  Each entry\'s `supported_parameters` is backed by live capability probes of the model\'s upstreams: it is the list to check before sending a gated parameter (`response_format`, `structured_outputs`, `logprobs`, `tools`, `vision`, ...).  One exception to \"the same body\": a key with a model allowlist (`allowed_models`) sees only the models on its list.  Each entry may carry a `metrics` object (always the last key): measured time to first token, decode rate and success rate over a rolling window of deeprelay customer traffic. Below the sample minimum `insufficient_data` is true and the figure is omitted, never zero.
      * List available models (OpenAI-compatible)
      */
     listModels() {

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

@@ -1,6 +1,6 @@
 /**
  * deeprelay Public Developer API
- * Programmatic API for deeprelay. Authenticate with API keys minted from the dashboard. See https://deeprelay.ai/docs for details.
+ * Programmatic API for deeprelay. Authenticate with API keys minted from the dashboard. See https://deeprelay.ai/docs for details.  Keys minted from the dashboard or `deeprelay login` belong to the Production server, https://api.deeprelay.ai/v1. The Demo server is an internal staging environment with its own key store.  Versioning: `/v1` is the API version. `info.version` is the revision of this `/v1` document, not a separate API.  OpenAI compatibility: chat completions follow the OpenAI request and response shapes, but not every OpenAI parameter is carried. Some are rejected with 400 `unsupported_parameter` and any parameter not declared in this spec is accepted and ignored. The full table is at https://deeprelay.ai/docs/api/inference#openai-compatibility.
  *
  * The version of the OpenAPI document: 1.0.0
  * Contact: support@deeprelay.ai

package/dist/esm/apis/MetaApi.js

@@ -2,7 +2,7 @@
 /* eslint-disable */
 /**
  * deeprelay Public Developer API
- * Programmatic API for deeprelay. Authenticate with API keys minted from the dashboard. See https://deeprelay.ai/docs for details.
+ * Programmatic API for deeprelay. Authenticate with API keys minted from the dashboard. See https://deeprelay.ai/docs for details.  Keys minted from the dashboard or `deeprelay login` belong to the Production server, https://api.deeprelay.ai/v1. The Demo server is an internal staging environment with its own key store.  Versioning: `/v1` is the API version. `info.version` is the revision of this `/v1` document, not a separate API.  OpenAI compatibility: chat completions follow the OpenAI request and response shapes, but not every OpenAI parameter is carried. Some are rejected with 400 `unsupported_parameter` and any parameter not declared in this spec is accepted and ignored. The full table is at https://deeprelay.ai/docs/api/inference#openai-compatibility.
  *
  * The version of the OpenAPI document: 1.0.0
  * Contact: support@deeprelay.ai

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

@@ -0,0 +1,130 @@
+/**
+ * deeprelay Public Developer API
+ * Programmatic API for deeprelay. Authenticate with API keys minted from the dashboard. See https://deeprelay.ai/docs for details.  Keys minted from the dashboard or `deeprelay login` belong to the Production server, https://api.deeprelay.ai/v1. The Demo server is an internal staging environment with its own key store.  Versioning: `/v1` is the API version. `info.version` is the revision of this `/v1` document, not a separate API.  OpenAI compatibility: chat completions follow the OpenAI request and response shapes, but not every OpenAI parameter is carried. Some are rejected with 400 `unsupported_parameter` and any parameter not declared in this spec is accepted and ignored. The full table is at https://deeprelay.ai/docs/api/inference#openai-compatibility.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: support@deeprelay.ai
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import * as runtime from '../runtime';
+import { type RequestLogEntry } from '../models/RequestLogEntry';
+import { type RequestLogPage } from '../models/RequestLogPage';
+export interface ExportRequestsRequest {
+    key?: string;
+    model?: string;
+    surface?: ExportRequestsSurfaceEnum;
+    status?: ExportRequestsStatusEnum;
+    errorCode?: string;
+    clientRequestId?: string;
+    from?: Date;
+    to?: Date;
+}
+export interface GetRequestRequest {
+    id: string;
+}
+export interface ListRequestsRequest {
+    key?: string;
+    model?: string;
+    surface?: ListRequestsSurfaceEnum;
+    status?: ListRequestsStatusEnum;
+    errorCode?: string;
+    clientRequestId?: string;
+    from?: Date;
+    to?: Date;
+    cursor?: string;
+    limit?: number;
+}
+/**
+ *
+ */
+export declare class RequestsApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for exportRequests without sending the request
+     */
+    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.
+     * 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.
+     * Export the request log as CSV
+     */
+    exportRequests(requestParameters?: ExportRequestsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string>;
+    /**
+     * Creates request options for getRequest without sending the request
+     */
+    getRequestRequestOpts(requestParameters: GetRequestRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Returns one request-log row. An unknown id, an id older than 90 days and an id the caller cannot see all answer the same 404. Requires the `serverless:read` scope.
+     * Get one request
+     */
+    getRequestRaw(requestParameters: GetRequestRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RequestLogEntry>>;
+    /**
+     * Returns one request-log row. An unknown id, an id older than 90 days and an id the caller cannot see all answer the same 404. Requires the `serverless:read` scope.
+     * Get one request
+     */
+    getRequest(requestParameters: GetRequestRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RequestLogEntry>;
+    /**
+     * Creates request options for listRequests without sending the request
+     */
+    listRequestsRequestOpts(requestParameters: ListRequestsRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Returns one newest-first page of the organization\'s inference request log: one row per call to chat completions, messages, responses, embeddings, image generation or video creation, including calls that were refused before they reached a model (`status: rejected`). Rows are kept for 90 days; `window_days` says how far back the log reaches, and a `from` older than that is clamped rather than rejected.  Visibility follows the caller. An org admin\'s key and a `full_access` key see the whole organization; any other key sees only its own rows. A `key` filter naming a key the caller cannot see returns an empty page.  A row never carries prompt or completion content. `client_request_id` is the value the caller sent in `X-Client-Request-Id` (or `metadata.client_request_id` on `/responses`), kept for correlation.  Requires the `serverless:read` scope. Reads are rate-limited per key (429 `rate_limited` with Retry-After).
+     * List requests (the request log)
+     */
+    listRequestsRaw(requestParameters: ListRequestsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RequestLogPage>>;
+    /**
+     * Returns one newest-first page of the organization\'s inference request log: one row per call to chat completions, messages, responses, embeddings, image generation or video creation, including calls that were refused before they reached a model (`status: rejected`). Rows are kept for 90 days; `window_days` says how far back the log reaches, and a `from` older than that is clamped rather than rejected.  Visibility follows the caller. An org admin\'s key and a `full_access` key see the whole organization; any other key sees only its own rows. A `key` filter naming a key the caller cannot see returns an empty page.  A row never carries prompt or completion content. `client_request_id` is the value the caller sent in `X-Client-Request-Id` (or `metadata.client_request_id` on `/responses`), kept for correlation.  Requires the `serverless:read` scope. Reads are rate-limited per key (429 `rate_limited` with Retry-After).
+     * List requests (the request log)
+     */
+    listRequests(requestParameters?: ListRequestsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RequestLogPage>;
+}
+/**
+ * @export
+ */
+export declare const ExportRequestsSurfaceEnum: {
+    readonly Chat: "chat";
+    readonly Messages: "messages";
+    readonly Responses: "responses";
+    readonly Embeddings: "embeddings";
+    readonly Image: "image";
+    readonly Video: "video";
+};
+export type ExportRequestsSurfaceEnum = typeof ExportRequestsSurfaceEnum[keyof typeof ExportRequestsSurfaceEnum];
+/**
+ * @export
+ */
+export declare const ExportRequestsStatusEnum: {
+    readonly Ok: "ok";
+    readonly Error: "error";
+    readonly Cancelled: "cancelled";
+    readonly Rejected: "rejected";
+};
+export type ExportRequestsStatusEnum = typeof ExportRequestsStatusEnum[keyof typeof ExportRequestsStatusEnum];
+/**
+ * @export
+ */
+export declare const ListRequestsSurfaceEnum: {
+    readonly Chat: "chat";
+    readonly Messages: "messages";
+    readonly Responses: "responses";
+    readonly Embeddings: "embeddings";
+    readonly Image: "image";
+    readonly Video: "video";
+};
+export type ListRequestsSurfaceEnum = typeof ListRequestsSurfaceEnum[keyof typeof ListRequestsSurfaceEnum];
+/**
+ * @export
+ */
+export declare const ListRequestsStatusEnum: {
+    readonly Ok: "ok";
+    readonly Error: "error";
+    readonly Cancelled: "cancelled";
+    readonly Rejected: "rejected";
+};
+export type ListRequestsStatusEnum = typeof ListRequestsStatusEnum[keyof typeof ListRequestsStatusEnum];

package/dist/esm/apis/RequestsApi.js

@@ -0,0 +1,265 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * deeprelay Public Developer API
+ * Programmatic API for deeprelay. Authenticate with API keys minted from the dashboard. See https://deeprelay.ai/docs for details.  Keys minted from the dashboard or `deeprelay login` belong to the Production server, https://api.deeprelay.ai/v1. The Demo server is an internal staging environment with its own key store.  Versioning: `/v1` is the API version. `info.version` is the revision of this `/v1` document, not a separate API.  OpenAI compatibility: chat completions follow the OpenAI request and response shapes, but not every OpenAI parameter is carried. Some are rejected with 400 `unsupported_parameter` and any parameter not declared in this spec is accepted and ignored. The full table is at https://deeprelay.ai/docs/api/inference#openai-compatibility.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: support@deeprelay.ai
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as runtime from '../runtime';
+import { RequestLogEntryFromJSON, } from '../models/RequestLogEntry';
+import { RequestLogPageFromJSON, } from '../models/RequestLogPage';
+/**
+ *
+ */
+export class RequestsApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for exportRequests without sending the request
+     */
+    exportRequestsRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParameters = {};
+            if (requestParameters['key'] != null) {
+                queryParameters['key'] = requestParameters['key'];
+            }
+            if (requestParameters['model'] != null) {
+                queryParameters['model'] = requestParameters['model'];
+            }
+            if (requestParameters['surface'] != null) {
+                queryParameters['surface'] = requestParameters['surface'];
+            }
+            if (requestParameters['status'] != null) {
+                queryParameters['status'] = requestParameters['status'];
+            }
+            if (requestParameters['errorCode'] != null) {
+                queryParameters['error_code'] = requestParameters['errorCode'];
+            }
+            if (requestParameters['clientRequestId'] != null) {
+                queryParameters['client_request_id'] = requestParameters['clientRequestId'];
+            }
+            if (requestParameters['from'] != null) {
+                queryParameters['from'] = requestParameters['from'].toISOString();
+            }
+            if (requestParameters['to'] != null) {
+                queryParameters['to'] = requestParameters['to'].toISOString();
+            }
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/requests/export`;
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * 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.
+     * Export the request log as CSV
+     */
+    exportRequestsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.exportRequestsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            if (this.isJsonMime(response.headers.get('content-type'))) {
+                return new runtime.JSONApiResponse(response);
+            }
+            else {
+                return new runtime.TextApiResponse(response);
+            }
+        });
+    }
+    /**
+     * 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.
+     * Export the request log as CSV
+     */
+    exportRequests() {
+        return __awaiter(this, arguments, void 0, function* (requestParameters = {}, initOverrides) {
+            const response = yield this.exportRequestsRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getRequest without sending the request
+     */
+    getRequestRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getRequest().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/requests/{id}`;
+            urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Returns one request-log row. An unknown id, an id older than 90 days and an id the caller cannot see all answer the same 404. Requires the `serverless:read` scope.
+     * Get one request
+     */
+    getRequestRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getRequestRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => RequestLogEntryFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Returns one request-log row. An unknown id, an id older than 90 days and an id the caller cannot see all answer the same 404. Requires the `serverless:read` scope.
+     * Get one request
+     */
+    getRequest(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getRequestRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for listRequests without sending the request
+     */
+    listRequestsRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParameters = {};
+            if (requestParameters['key'] != null) {
+                queryParameters['key'] = requestParameters['key'];
+            }
+            if (requestParameters['model'] != null) {
+                queryParameters['model'] = requestParameters['model'];
+            }
+            if (requestParameters['surface'] != null) {
+                queryParameters['surface'] = requestParameters['surface'];
+            }
+            if (requestParameters['status'] != null) {
+                queryParameters['status'] = requestParameters['status'];
+            }
+            if (requestParameters['errorCode'] != null) {
+                queryParameters['error_code'] = requestParameters['errorCode'];
+            }
+            if (requestParameters['clientRequestId'] != null) {
+                queryParameters['client_request_id'] = requestParameters['clientRequestId'];
+            }
+            if (requestParameters['from'] != null) {
+                queryParameters['from'] = requestParameters['from'].toISOString();
+            }
+            if (requestParameters['to'] != null) {
+                queryParameters['to'] = requestParameters['to'].toISOString();
+            }
+            if (requestParameters['cursor'] != null) {
+                queryParameters['cursor'] = requestParameters['cursor'];
+            }
+            if (requestParameters['limit'] != null) {
+                queryParameters['limit'] = requestParameters['limit'];
+            }
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/requests`;
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Returns one newest-first page of the organization\'s inference request log: one row per call to chat completions, messages, responses, embeddings, image generation or video creation, including calls that were refused before they reached a model (`status: rejected`). Rows are kept for 90 days; `window_days` says how far back the log reaches, and a `from` older than that is clamped rather than rejected.  Visibility follows the caller. An org admin\'s key and a `full_access` key see the whole organization; any other key sees only its own rows. A `key` filter naming a key the caller cannot see returns an empty page.  A row never carries prompt or completion content. `client_request_id` is the value the caller sent in `X-Client-Request-Id` (or `metadata.client_request_id` on `/responses`), kept for correlation.  Requires the `serverless:read` scope. Reads are rate-limited per key (429 `rate_limited` with Retry-After).
+     * List requests (the request log)
+     */
+    listRequestsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.listRequestsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => RequestLogPageFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Returns one newest-first page of the organization\'s inference request log: one row per call to chat completions, messages, responses, embeddings, image generation or video creation, including calls that were refused before they reached a model (`status: rejected`). Rows are kept for 90 days; `window_days` says how far back the log reaches, and a `from` older than that is clamped rather than rejected.  Visibility follows the caller. An org admin\'s key and a `full_access` key see the whole organization; any other key sees only its own rows. A `key` filter naming a key the caller cannot see returns an empty page.  A row never carries prompt or completion content. `client_request_id` is the value the caller sent in `X-Client-Request-Id` (or `metadata.client_request_id` on `/responses`), kept for correlation.  Requires the `serverless:read` scope. Reads are rate-limited per key (429 `rate_limited` with Retry-After).
+     * List requests (the request log)
+     */
+    listRequests() {
+        return __awaiter(this, arguments, void 0, function* (requestParameters = {}, initOverrides) {
+            const response = yield this.listRequestsRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+}
+/**
+ * @export
+ */
+export const ExportRequestsSurfaceEnum = {
+    Chat: 'chat',
+    Messages: 'messages',
+    Responses: 'responses',
+    Embeddings: 'embeddings',
+    Image: 'image',
+    Video: 'video'
+};
+/**
+ * @export
+ */
+export const ExportRequestsStatusEnum = {
+    Ok: 'ok',
+    Error: 'error',
+    Cancelled: 'cancelled',
+    Rejected: 'rejected'
+};
+/**
+ * @export
+ */
+export const ListRequestsSurfaceEnum = {
+    Chat: 'chat',
+    Messages: 'messages',
+    Responses: 'responses',
+    Embeddings: 'embeddings',
+    Image: 'image',
+    Video: 'video'
+};
+/**
+ * @export
+ */
+export const ListRequestsStatusEnum = {
+    Ok: 'ok',
+    Error: 'error',
+    Cancelled: 'cancelled',
+    Rejected: 'rejected'
+};