@spicyapi/sdk 0.1.0 → 0.2.1

package/dist/src/generated/openapi.d.ts

@@ -3,6 +3,33 @@
  * Do not make direct changes to the file.
  */
 export interface paths {
+    "/api/v1/jobs/quote": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Quote a task before reserving funds
+         * @description Validates the same model input and admission rules as task creation,
+         *     without creating a task, reserving funds or starting generation.
+         *     The signed quote is bound to this account, API key and request and is
+         *     valid for five minutes. Pass quoteId and expectedCost with the same
+         *     request to createTask or jobs/stream. New acceptance rejects an expired
+         *     or changed quote with business code 40901. A replay of an already
+         *     accepted Idempotency-Key still returns the original task.
+         *     A quote does not reserve capacity or guarantee future availability.
+         */
+        post: operations["quoteTask"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/jobs/createTask": {
         parameters: {
             query?: never;
@@ -20,7 +47,7 @@ export interface paths {
          *
          *     An `Idempotency-Key` is optional but strongly recommended. For the same
          *     account **and the same API key**, repeating a key with the same normalized
-         *     model, input, callback URL, and mature flag within 24 hours returns the
+         *     model, input, and callback URL within 24 hours returns the
          *     original task and does not reserve funds twice. A sibling API key cannot
          *     replay the mapping: it receives `409 Conflict` without the original task
          *     ID. Reusing the key with different request semantics also returns
@@ -51,6 +78,39 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/jobs/stream": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Run a text model and stream the answer
+         * @description Text models only. Applies the same validation, quota, pricing and hold as
+         *     `createTask`, then keeps the connection open and returns the model answer
+         *     as a Server-Sent Events stream. Each event is a `data:` line carrying one
+         *     JSON chunk; the stream ends with `data: [DONE]`.
+         *
+         *     The hold is settled when the stream completes. If the upstream call fails
+         *     before the first event, the response is a normal JSON error and the hold is
+         *     released. If it fails mid-stream the connection is terminated with an
+         *     `error` event and the hold is still released — a truncated answer is never
+         *     charged as a completed one.
+         *
+         *     Generation models (image, video, audio) are asynchronous and must use
+         *     `createTask` with `recordInfo` polling; calling this endpoint for them
+         *     returns `503`.
+         */
+        post: operations["streamTask"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/jobs/retry": {
         parameters: {
             query?: never;
@@ -108,7 +168,7 @@ export interface paths {
          * Get one model, including its input JSON Schema
          * @description `model` is the exact value used by `createTask.model` and may contain
          *     slashes. URL-encode embedded slashes when using clients that treat path
-         *     parameters as one segment (for example `bytedance%2Fseedance-2-fast`).
+         *     parameters as one segment (for example `family%2Fversion%2Ftask`).
          */
         get: operations["getModel"];
         put?: never;
@@ -149,7 +209,9 @@ export interface paths {
          * Create a presigned image upload ticket
          * @description The server generates the object key. Upload the exact declared number of
          *     bytes with PUT and copy every returned header. Supported media types are
-         *     JPEG, PNG, WebP, and GIF; the default maximum is 10 MiB. After PUT,
+         *     JPEG, PNG, WebP and GIF images (10 MiB), or MP4/WebM video and
+         *     MP3/WAV audio (100 MiB, at most 600 seconds). Audio/video commit verifies
+         *     format and measurable duration; it does not inspect adult content. After PUT,
          *     call the file commit endpoint and use its spicy:// URI in task input.
          */
         post: operations["createUploadUrl"];
@@ -172,8 +234,10 @@ export interface paths {
          * Commit a completed direct upload
          * @description Compares the stored byte count and media type with the ticket, checks
          *     the image signature, computes SHA-256, and copies the temporary object
-         *     to an immutable private key. Only the returned spicy:// URI can be used
-         *     in task input. Repeating a successful commit is idempotent.
+         *     to an immutable private key. Reference this uploaded file with the returned
+         *     spicy:// URI. Publicly accessible HTTPS media URLs can instead be passed
+         *     directly in supported model input fields, without uploading. Repeating
+         *     a successful commit is idempotent.
          */
         post: operations["commitUploadedFile"];
         delete?: never;
@@ -203,6 +267,194 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/models": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List callable models in the OpenAI `model` list shape
+         * @description Returns every model that can be called right now. `id` is the SpicyAPI
+         *     model identifier accepted by every `/v1` and `/api/v1` operation;
+         *     `owned_by` is the model publisher (for example a research lab), never
+         *     an execution supplier. Pricing is not included; use `/api/v1/models`.
+         */
+        get: operations["listOpenAIModels"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/chat/completions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * OpenAI Chat Completions on a SpicyAPI text model
+         * @description Accepts an OpenAI Chat Completions request. `messages`, `tools`,
+         *     `tool_choice`, `response_format`, `max_tokens` (or
+         *     `max_completion_tokens`), `temperature` and `top_p` map onto the
+         *     model's public input fields of the same name; `stream`,
+         *     `stream_options`, `user`, `metadata` and `store` are handled by this
+         *     layer. Any other parameter is forwarded to the model's input schema
+         *     and rejected with `400` when the model does not declare it — a
+         *     parameter is never dropped silently.
+         *
+         *     `stream: true` returns a Server-Sent Events stream of
+         *     `chat.completion.chunk` objects terminated by `data: [DONE]`.
+         *     `stream: false` returns one `chat.completion` object. The same hold,
+         *     settlement and refund rules as `/api/v1/jobs/stream` apply.
+         */
+        post: operations["createChatCompletion"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/responses": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * OpenAI Responses API subset on a SpicyAPI text model
+         * @description Accepts the stateless subset of the OpenAI Responses API: `model`,
+         *     `input` (string or item array with `message`, `function_call` and
+         *     `function_call_output` items), `instructions`, `max_output_tokens`,
+         *     `temperature`, `top_p`, `tools` (function tools), `tool_choice`,
+         *     `text.format`, `reasoning.effort` and `stream`. The request is
+         *     translated to a chat completion internally. `previous_response_id`
+         *     is rejected with `400`; send the full history in `input` instead.
+         *
+         *     Non-streaming calls return a `response` object with `output[]`
+         *     (`message` and `function_call` items) and `usage`. Streaming calls
+         *     emit `response.created`, `response.output_text.delta` and
+         *     `response.completed` events.
+         */
+        post: operations["createResponse"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/messages": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Anthropic Messages API on a SpicyAPI text model
+         * @description Accepts an Anthropic Messages request (`model`, `system`, `messages`
+         *     with text / image / tool_use / tool_result blocks, `max_tokens`,
+         *     `temperature`, `top_p`, `stop_sequences`, `tools`, `tool_choice`,
+         *     `stream`) and translates it to a chat completion internally.
+         *     Non-streaming calls return an Anthropic `message` object. Streaming
+         *     calls emit `message_start`, `content_block_start`,
+         *     `content_block_delta`, `content_block_stop`, `message_delta` and
+         *     `message_stop` events. Errors use the Anthropic
+         *     `{type:"error",error:{type,message}}` shape.
+         */
+        post: operations["createMessage"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/videos": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Create a video generation task in the OpenAI Videos shape
+         * @description Projection of `createTask` onto the OpenAI Videos API. `model` must be
+         *     a video endpoint identifier from `/v1/models`. `prompt` maps to the
+         *     model's `prompt`; `input_reference` (an HTTPS URL or a committed
+         *     `spicy://` upload) maps to `image_url` / `image_urls`; `seconds` maps to
+         *     `duration_seconds`; `size` (`WIDTHxHEIGHT`) maps to `resolution` and/or
+         *     `aspect_ratio`, or to `width` / `height` when the model declares pixel
+         *     dimensions. A parameter the selected model does not declare is
+         *     rejected with `400`. The same hold and idempotency rules as
+         *     `createTask` apply; the returned object never contains prices.
+         */
+        post: operations["createVideo"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/videos/{videoId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Retrieve a video task as an OpenAI `video` object
+         * @description Task states map to `queued` → `queued`, `running` → `in_progress`,
+         *     `succeeded` → `completed`, and `failed` / `canceled` / `expired` →
+         *     `failed` with an `error` object. Only the account and API key that
+         *     created the task can read it; other identifiers return `404`.
+         */
+        get: operations["retrieveVideo"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/videos/{videoId}/content": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Redirect to the generated video file
+         * @description Responds `302 Found` with a short-lived signed download URL for the
+         *     task's primary output, the same address `/api/v1/common/download-url`
+         *     would issue. `409` while the task is still queued or running; `404`
+         *     when the task failed or has no downloadable output.
+         */
+        get: operations["downloadVideoContent"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -215,7 +467,7 @@ export interface components {
         };
         ErrorEnvelope: components["schemas"]["EnvelopeBase"] & {
             /** @enum {integer} */
-            code?: 400 | 401 | 40201 | 40202 | 403 | 40301 | 40302 | 40303 | 404 | 409 | 413 | 429 | 500 | 50301;
+            code?: 400 | 401 | 40201 | 40202 | 403 | 40301 | 40302 | 40303 | 404 | 409 | 40901 | 413 | 429 | 500 | 50301;
             msg?: string;
         };
         CreateTaskRequest: {
@@ -227,14 +479,30 @@ export interface components {
             };
             /**
              * Format: uri
-             * @description Optional public HTTP(S) endpoint for terminal task delivery.
+             * @description Optional public HTTP(S) endpoint for terminal task delivery; HTTPS is recommended. Only ports 80 and 443 are allowed, and URL credentials are rejected. The hostname must resolve to public IP addresses and is checked again when connecting. Invalid values return HTTP 400 with code 400, msg "Invalid callback URL", and request_id.
              */
             callBackUrl?: string;
-            /**
-             * @description Optional execution metadata passed through to the selected model. The platform applies no account, API-key, model-capability, channel-capability, or content-preflight gate to this field.
-             * @default false
-             */
-            mature: boolean;
+            /** @description Signed quote returned by jobs/quote for this same account, API key and request. Does not replace Idempotency-Key. */
+            quoteId?: string;
+            /** @description Confirmed amount to reserve, with up to nine decimal places. A changed price returns business code 40901 before reservation. */
+            expectedCost?: components["schemas"]["USDString"];
+        };
+        TaskQuoteResponse: {
+            quoteId: string;
+            /** @description Resolved endpoint model identifier. */
+            model: string;
+            estimatedCost: components["schemas"]["USDString"];
+            maxCharge: components["schemas"]["USDString"];
+            /** @constant */
+            currency: "USD";
+            /** @description Estimated billable quantity. */
+            quantity: string;
+            unit: string;
+            /** Format: date-time */
+            expiresAt: string;
+        };
+        TaskQuoteEnvelope: components["schemas"]["EnvelopeBase"] & {
+            data: components["schemas"]["TaskQuoteResponse"];
         };
         CreateTaskResponse: {
             taskId: string;
@@ -243,7 +511,7 @@ export interface components {
              * @enum {string}
              */
             state: "queued" | "running" | "succeeded" | "failed" | "canceled" | "expired";
-            /** @description Funds held when the task is accepted and the maximum amount charged for that task. Unused funds are released; provider overage is absorbed by the platform. */
+            /** @description Funds held when the task is accepted and the maximum customer charge for that task. Unused funds are released and no later amount is collected above the hold. */
             estimatedCost: components["schemas"]["USDString"];
         };
         TaskActionRequest: {
@@ -266,6 +534,39 @@ export interface components {
             msg?: "success";
             data: components["schemas"]["CreateTaskResponse"];
         };
+        /** @description First-party result metadata. Ready assets include directly usable temporary URLs; no download-ticket request is needed. Poll again to refresh an expired URL. Temporary URLs are bearer access grants; never attach your API key when fetching them. */
+        TaskOutput: {
+            text?: string;
+            assets?: components["schemas"]["TaskOutputAsset"][];
+        } & {
+            [key: string]: unknown;
+        };
+        TaskOutputAsset: {
+            /** @description Compatibility identifier for optional download-url requests. */
+            key?: string;
+            /**
+             * Format: uri
+             * @description First-party signed GET URL
+             */
+            url?: string;
+            /**
+             * Format: date-time
+             * @description Expiry of this URL
+             */
+            expiresAt?: string;
+            mime?: string;
+            width?: number;
+            height?: number;
+            durationSeconds?: number;
+            /** Format: int64 */
+            bytes?: number;
+            role?: string;
+            nsfw?: boolean;
+            pending?: boolean;
+            unavailable?: boolean;
+        } & {
+            [key: string]: unknown;
+        };
         TaskRecord: {
             taskId: string;
             /** @description Present when this task was created by explicit retry. */
@@ -277,11 +578,10 @@ export interface components {
             input?: {
                 [key: string]: unknown;
             };
-            /** @description Normalized model output when available. Omitted after retention redaction. */
-            output?: {
-                [key: string]: unknown;
-            };
+            output?: components["schemas"]["TaskOutput"];
+            /** @description Stable SpicyAPI failure identifier; never a raw execution-channel code. */
             errorCode?: string;
+            /** @description Safe normalized explanation without internal service names */
             errorMessage?: string;
             cost: components["schemas"]["USDString"];
             /** @description When false, `cost` is the held estimate. On success the final charge is capped at that hold; unused funds are released. Failed or expired tasks release the hold in full. */
@@ -334,14 +634,24 @@ export interface components {
             /** @enum {string} */
             unit: "per_image" | "per_second" | "per_request" | "per_1k_tokens";
             price: components["schemas"]["USDString"];
+            regularPrice?: components["schemas"]["USDString"];
+            offerLabel?: string;
+            offerPercent?: string;
+            /** Format: date-time */
+            offerEndsAt?: string;
             /** @constant */
             currency: "USD";
         };
         APIModel: {
+            /**
+             * @description Preferred callable identifier in publisher/model/task form. Image editing uses the edit suffix; previously published identifiers remain accepted.
+             * @example bytedance/seedream-5.0-lite/edit
+             */
             model: string;
             /** @description Stable product-family identifier; endpoint variants are listed in `tasks` and expressed by `inputSchema`. */
             family: string;
             displayName: string;
+            /** @description Model creator/author identifier. It never identifies an execution channel. */
             provider: string;
             /** @enum {string} */
             modality: "image" | "video" | "audio" | "text";
@@ -356,18 +666,18 @@ export interface components {
             policyTier: "unrestricted" | "borderline" | "unspecified";
             /** @description Absolute platform execution deadline before timeout/refund; not media output duration. */
             taskTimeoutSeconds: number;
-            /** @description Maximum `input.duration` accepted by the model schema; omitted when the model has no declared duration maximum. */
+            /** @description Maximum output duration the model schema allows, taken from the `maximum` of its `duration_seconds` property; omitted when that property is absent or has no declared maximum. Distinct from `taskTimeoutSeconds`, which is the platform execution deadline. */
             maxOutputDurationSeconds?: number;
             enabled: boolean;
             available: boolean;
             quantityField: string;
             pricing: components["schemas"]["APIModelPrice"][];
             startingPrice?: components["schemas"]["APIModelPrice"];
-            /** @description JSON Schema draft 2020-12 used by `createTask.input` validation. */
+            /** @description JSON Schema draft 2020-12 used by `createTask.input` validation and Playground rendering. Standard JSON Schema keywords validate. Presentation hints live only in a per-property `x-ui` object whose keys are snake_case and drawn from a closed set: `widget`, `order`, `label`, `placeholder`, `rows`, `step`, `unit`, `accept`, `max_size_mb`, `advanced`, `primary`, `affects_price`, `visible_when`, `enum_labels`. `x-ui.order` is the only source of field order (descending first). `x-ui.widget` is one of `textarea`, `text`, `upload`, `multi-upload`, `select`, `radio`, `slider`, `number`, `switch`, `json`, `object-list`, `chat-messages`, `hidden`. Root-level composition is limited to `anyOf`, where every branch contains only `required`, and `allOf`, where each branch is `if` (`required` or `properties.*.const`) plus `then` (`required`); `oneOf`, `not` and `dependentSchemas` never appear. Unknown hints must be ignored. */
             inputSchema?: {
                 [key: string]: unknown;
             };
-            /** @description Provider/model version label used to detect catalog changes. */
+            /** @description Public model-catalog version label used to detect schema or metadata changes. */
             version: string;
             /** @enum {string} */
             availability: "planned" | "available" | "preview" | "maintenance";
@@ -407,7 +717,8 @@ export interface components {
         };
         UploadURLRequest: {
             /** @enum {string} */
-            contentType: "image/jpeg" | "image/png" | "image/webp" | "image/gif";
+            contentType: "image/jpeg" | "image/png" | "image/webp" | "image/gif" | "video/mp4" | "video/webm" | "audio/mpeg" | "audio/wav";
+            /** @description Images are limited to 10 MiB; supported audio/video to 100 MiB. */
             bytes: number;
         };
         UploadURLResponse: {
@@ -438,11 +749,15 @@ export interface components {
             status: "ready";
             bytes: number;
             /** @enum {string} */
-            contentType: "image/jpeg" | "image/png" | "image/webp" | "image/gif";
+            contentType: "image/jpeg" | "image/png" | "image/webp" | "image/gif" | "video/mp4" | "video/webm" | "audio/mpeg" | "audio/wav";
             sha256: string;
             uri: string;
             /** Format: date-time */
             expiresAt: string;
+            /** @description Measured audio/video duration in seconds. */
+            durationSeconds?: string;
+            width?: number;
+            height?: number;
         };
         FileCommitEnvelope: components["schemas"]["EnvelopeBase"] & {
             /** @constant */
@@ -472,9 +787,233 @@ export interface components {
         };
         /** @description Decimal USD amount encoded as a string to avoid binary floating-point loss. */
         USDString: string;
+        OpenAIErrorBody: {
+            error: {
+                message: string;
+                /** @enum {string} */
+                type: "invalid_request_error" | "authentication_error" | "permission_error" | "insufficient_quota" | "rate_limit_error" | "server_error";
+                param?: string | null;
+                /** @description Stable machine-readable reason, for example `invalid_request`, `invalid_api_key`, `insufficient_balance`, `model_not_allowed`, `model_unavailable`, `rate_limit_exceeded`. */
+                code: string;
+            };
+        };
+        AnthropicErrorBody: {
+            /** @constant */
+            type: "error";
+            error: {
+                /** @enum {string} */
+                type: "invalid_request_error" | "authentication_error" | "billing_error" | "permission_error" | "not_found_error" | "request_too_large" | "rate_limit_error" | "api_error" | "overloaded_error";
+                message: string;
+            };
+        };
+        OpenAIModelList: {
+            /** @constant */
+            object: "list";
+            data: {
+                /** @description SpicyAPI model identifier; may contain slashes. */
+                id: string;
+                /** @constant */
+                object: "model";
+                /** @description Unix seconds of the last catalog update. */
+                created: number;
+                /** @description Model publisher. */
+                owned_by: string;
+            }[];
+        };
+        ChatCompletionRequest: {
+            model: string;
+            messages: ({
+                role: string;
+                content?: (string | null) | {
+                    [key: string]: unknown;
+                }[];
+                tool_call_id?: string;
+                tool_calls?: {
+                    [key: string]: unknown;
+                }[];
+                /** @description Optional assistant reasoning text; availability and message roles follow the selected model input schema. */
+                reasoning_content?: string;
+            } & {
+                [key: string]: unknown;
+            })[];
+            /** @default false */
+            stream: boolean;
+            max_tokens?: number;
+            /** @description Alias of `max_tokens`. */
+            max_completion_tokens?: number;
+            temperature?: number;
+            top_p?: number;
+            tools?: {
+                [key: string]: unknown;
+            }[];
+            tool_choice?: string | {
+                [key: string]: unknown;
+            };
+            response_format?: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        };
+        ChatCompletion: {
+            id: string;
+            /** @constant */
+            object: "chat.completion";
+            created: number;
+            model: string;
+            choices: {
+                index: number;
+                message: {
+                    role?: string;
+                    content?: string | null;
+                    refusal?: string;
+                    /** @description Optional reasoning text returned by models that expose it. Streaming chunks use the same field in delta. */
+                    reasoning_content?: string;
+                    tool_calls?: {
+                        [key: string]: unknown;
+                    }[];
+                };
+                finish_reason: string;
+                logprobs?: null;
+            }[];
+            usage?: {
+                prompt_tokens?: number;
+                completion_tokens?: number;
+                total_tokens?: number;
+                prompt_tokens_details?: {
+                    cached_tokens?: number;
+                    cache_creation_input_tokens?: number;
+                    cache_read_input_tokens?: number;
+                };
+                completion_tokens_details?: {
+                    /** @description Included in completion_tokens; do not add it again when calculating usage. */
+                    reasoning_tokens?: number;
+                };
+            };
+        };
+        ResponsesRequest: {
+            model: string;
+            input: string | Record<string, never>[];
+            instructions?: string;
+            max_output_tokens?: number;
+            temperature?: number;
+            top_p?: number;
+            tools?: Record<string, never>[];
+            tool_choice?: string | Record<string, never>;
+            text?: Record<string, never>;
+            reasoning?: {
+                effort?: string;
+            };
+            /** @default false */
+            stream: boolean;
+        };
+        ResponseObject: {
+            id: string;
+            /** @constant */
+            object: "response";
+            created_at: number;
+            /** @enum {string} */
+            status: "completed" | "incomplete" | "in_progress";
+            model: string;
+            output: {
+                id: string;
+                /** @enum {string} */
+                type: "message" | "function_call";
+                status: string;
+                role?: string;
+                content?: {
+                    /** @constant */
+                    type?: "output_text";
+                    text?: string;
+                    annotations?: Record<string, never>[];
+                }[];
+                call_id?: string;
+                name?: string;
+                arguments?: string;
+            }[];
+            error?: null;
+            incomplete_details?: {
+                reason?: string;
+            } | null;
+            usage?: {
+                input_tokens?: number;
+                output_tokens?: number;
+                total_tokens?: number;
+            };
+        };
+        AnthropicMessageRequest: {
+            model: string;
+            system?: string | Record<string, never>[];
+            messages: {
+                /** @enum {string} */
+                role: "user" | "assistant";
+                content: string | Record<string, never>[];
+            }[];
+            max_tokens: number;
+            temperature?: number;
+            top_p?: number;
+            stop_sequences?: string[];
+            tools?: Record<string, never>[];
+            tool_choice?: Record<string, never>;
+            /** @default false */
+            stream: boolean;
+        };
+        AnthropicMessage: {
+            id: string;
+            /** @constant */
+            type: "message";
+            /** @constant */
+            role: "assistant";
+            model: string;
+            content: {
+                /** @enum {string} */
+                type: "text" | "tool_use";
+                text?: string;
+                id?: string;
+                name?: string;
+                input?: Record<string, never>;
+            }[];
+            /** @enum {string} */
+            stop_reason: "end_turn" | "max_tokens" | "tool_use";
+            stop_sequence?: null;
+            usage: {
+                input_tokens?: number;
+                output_tokens?: number;
+            };
+        };
+        VideoCreateRequest: {
+            /** @description Video endpoint identifier from `/v1/models`. */
+            model: string;
+            prompt: string;
+            /** @description Reference image URL; mapped to the model's `image_url` / `image_urls`. */
+            input_reference?: string;
+            /** @description Clip length in seconds; mapped to `duration_seconds`. */
+            seconds?: string | number;
+            /** @description WIDTHxHEIGHT, mapped to `resolution` / `aspect_ratio` (or `width` / `height`). */
+            size?: string;
+        };
+        Video: {
+            /** @description Task identifier; also accepted by `/api/v1/jobs/recordInfo`. */
+            id: string;
+            /** @constant */
+            object: "video";
+            model: string;
+            /** @enum {string} */
+            status: "queued" | "in_progress" | "completed" | "failed";
+            /** @description 100 when completed */
+            progress: number;
+            created_at: number;
+            completed_at?: number;
+            seconds?: string;
+            size?: string;
+            error?: {
+                code: string;
+                message: string;
+            };
+        };
     };
     responses: {
-        /** @description Invalid JSON, query, callback URL, model input, or media declaration. */
+        /** @description Invalid JSON, query, callback URL, model input, or media declaration. Invalid callBackUrl values return code 400 and msg "Invalid callback URL" with request_id. Submitted hosts, IP addresses, and DNS diagnostics are not echoed. */
         BadRequest: {
             headers: {
                 [name: string]: unknown;
@@ -567,6 +1106,24 @@ export interface components {
                 "application/json": components["schemas"]["ErrorEnvelope"];
             };
         };
+        /** @description Error in the OpenAI `{error:{message,type,param,code}}` shape. The HTTP status is the same one `/api/v1` would return. */
+        OpenAIError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["OpenAIErrorBody"];
+            };
+        };
+        /** @description Error in the Anthropic `{type:"error",error:{type,message}}` shape. */
+        AnthropicError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["AnthropicErrorBody"];
+            };
+        };
     };
     parameters: {
         /** @description Stable key for one logical task submission; retained for 24 hours per account and bound to both the submitting API key and normalized request fingerprint. A sibling key receives 409 without the original task ID. */
@@ -585,6 +1142,38 @@ export interface components {
 }
 export type $defs = Record<string, never>;
 export interface operations {
+    quoteTask: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateTaskRequest"];
+            };
+        };
+        responses: {
+            /** @description Customer price and maximum charge; no funds were reserved. */
+            200: {
+                headers: {
+                    "Cache-Control"?: "no-store";
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TaskQuoteEnvelope"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            402: components["responses"]["PaymentRequired"];
+            403: components["responses"]["Forbidden"];
+            409: components["responses"]["Conflict"];
+            429: components["responses"]["RateLimited"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
     createTask: {
         parameters: {
             query?: never;
@@ -667,6 +1256,42 @@ export interface operations {
             500: components["responses"]["ServerError"];
         };
     };
+    streamTask: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Stable key for one logical task submission; retained for 24 hours per account and bound to both the submitting API key and normalized request fingerprint. A sibling key receives 409 without the original task ID. */
+                "Idempotency-Key"?: components["parameters"]["IdempotencyKey"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateTaskRequest"];
+            };
+        };
+        responses: {
+            /** @description Server-Sent Events stream of the model answer. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/event-stream": string;
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            402: components["responses"]["PaymentRequired"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            429: components["responses"]["RateLimited"];
+            500: components["responses"]["ServerError"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
     retryTask: {
         parameters: {
             query?: never;
@@ -708,6 +1333,7 @@ export interface operations {
         parameters: {
             query?: {
                 modality?: "image" | "video" | "audio" | "text";
+                /** @description Exact model creator/author identifier. This never identifies an execution channel. */
                 provider?: string;
                 /** @description Exact supported task, for example `text-to-image`. */
                 task?: string;
@@ -884,5 +1510,239 @@ export interface operations {
             500: components["responses"]["ServerError"];
         };
     };
+    listOpenAIModels: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OpenAI-style model list. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIModelList"];
+                };
+            };
+            401: components["responses"]["OpenAIError"];
+            403: components["responses"]["OpenAIError"];
+            429: components["responses"]["OpenAIError"];
+            500: components["responses"]["OpenAIError"];
+            503: components["responses"]["OpenAIError"];
+        };
+    };
+    createChatCompletion: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Stable key for one logical task submission; retained for 24 hours per account and bound to both the submitting API key and normalized request fingerprint. A sibling key receives 409 without the original task ID. */
+                "Idempotency-Key"?: components["parameters"]["IdempotencyKey"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ChatCompletionRequest"];
+            };
+        };
+        responses: {
+            /** @description One `chat.completion` object, or an SSE stream when `stream` is true. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ChatCompletion"];
+                    "text/event-stream": string;
+                };
+            };
+            400: components["responses"]["OpenAIError"];
+            401: components["responses"]["OpenAIError"];
+            402: components["responses"]["OpenAIError"];
+            403: components["responses"]["OpenAIError"];
+            404: components["responses"]["OpenAIError"];
+            409: components["responses"]["OpenAIError"];
+            413: components["responses"]["OpenAIError"];
+            429: components["responses"]["OpenAIError"];
+            500: components["responses"]["OpenAIError"];
+            503: components["responses"]["OpenAIError"];
+        };
+    };
+    createResponse: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Stable key for one logical task submission; retained for 24 hours per account and bound to both the submitting API key and normalized request fingerprint. A sibling key receives 409 without the original task ID. */
+                "Idempotency-Key"?: components["parameters"]["IdempotencyKey"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ResponsesRequest"];
+            };
+        };
+        responses: {
+            /** @description One `response` object, or an SSE stream when `stream` is true. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ResponseObject"];
+                    "text/event-stream": string;
+                };
+            };
+            400: components["responses"]["OpenAIError"];
+            401: components["responses"]["OpenAIError"];
+            402: components["responses"]["OpenAIError"];
+            403: components["responses"]["OpenAIError"];
+            404: components["responses"]["OpenAIError"];
+            409: components["responses"]["OpenAIError"];
+            413: components["responses"]["OpenAIError"];
+            429: components["responses"]["OpenAIError"];
+            500: components["responses"]["OpenAIError"];
+            503: components["responses"]["OpenAIError"];
+        };
+    };
+    createMessage: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Stable key for one logical task submission; retained for 24 hours per account and bound to both the submitting API key and normalized request fingerprint. A sibling key receives 409 without the original task ID. */
+                "Idempotency-Key"?: components["parameters"]["IdempotencyKey"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AnthropicMessageRequest"];
+            };
+        };
+        responses: {
+            /** @description One Anthropic `message` object, or an SSE stream when `stream` is true. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AnthropicMessage"];
+                    "text/event-stream": string;
+                };
+            };
+            400: components["responses"]["AnthropicError"];
+            401: components["responses"]["AnthropicError"];
+            402: components["responses"]["AnthropicError"];
+            403: components["responses"]["AnthropicError"];
+            404: components["responses"]["AnthropicError"];
+            409: components["responses"]["AnthropicError"];
+            413: components["responses"]["AnthropicError"];
+            429: components["responses"]["AnthropicError"];
+            500: components["responses"]["AnthropicError"];
+            503: components["responses"]["AnthropicError"];
+        };
+    };
+    createVideo: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Stable key for one logical task submission; retained for 24 hours per account and bound to both the submitting API key and normalized request fingerprint. A sibling key receives 409 without the original task ID. */
+                "Idempotency-Key"?: components["parameters"]["IdempotencyKey"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["VideoCreateRequest"];
+            };
+        };
+        responses: {
+            /** @description The accepted task as a `video` object in `queued` state (an idempotent replay reports the current state). */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Video"];
+                };
+            };
+            400: components["responses"]["OpenAIError"];
+            401: components["responses"]["OpenAIError"];
+            402: components["responses"]["OpenAIError"];
+            403: components["responses"]["OpenAIError"];
+            404: components["responses"]["OpenAIError"];
+            409: components["responses"]["OpenAIError"];
+            413: components["responses"]["OpenAIError"];
+            429: components["responses"]["OpenAIError"];
+            500: components["responses"]["OpenAIError"];
+            503: components["responses"]["OpenAIError"];
+        };
+    };
+    retrieveVideo: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                videoId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Current video task state. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Video"];
+                };
+            };
+            401: components["responses"]["OpenAIError"];
+            403: components["responses"]["OpenAIError"];
+            404: components["responses"]["OpenAIError"];
+            429: components["responses"]["OpenAIError"];
+            500: components["responses"]["OpenAIError"];
+            503: components["responses"]["OpenAIError"];
+        };
+    };
+    downloadVideoContent: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                videoId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Redirect to the signed media URL. The redirect must not be cached. */
+            302: {
+                headers: {
+                    /** @description Short-lived signed download URL. */
+                    Location?: string;
+                    "Cache-Control"?: "no-store";
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            401: components["responses"]["OpenAIError"];
+            403: components["responses"]["OpenAIError"];
+            404: components["responses"]["OpenAIError"];
+            409: components["responses"]["OpenAIError"];
+            429: components["responses"]["OpenAIError"];
+            500: components["responses"]["OpenAIError"];
+            503: components["responses"]["OpenAIError"];
+        };
+    };
 }
 //# sourceMappingURL=openapi.d.ts.map