@leaflow/sdk 0.140.0 → 0.142.0

package/README.md

@@ -18,6 +18,12 @@ npm run generate
 npm run build
 ```
 
-`orval.config.mjs` is plain official Orval configuration that recursively discovers OpenAPI entry documents. No custom generator,
-output postprocessing or compatibility forwarding layer is used. For local generation, CONTRACTS_DIR
+`orval.config.mjs` is plain official Orval configuration that recursively discovers OpenAPI entry documents. The Canopy hook chooses JSON or Blob for the chat completion response according to Content-Type,
+so JSON and SSE retain their respective response formats. No compatibility forwarding layer is used. For local generation, CONTRACTS_DIR
 may point to an existing clean checkout of the exact CONTRACTS_REF commit. CI checks out that commit.
+
+## Canopy migration
+
+Project inference and management are exported from `canopy` and `@leaflow/sdk/canopy/v1`.
+Replace `canopyInference` and `@leaflow/sdk/canopy/inference/v1` imports with the shared Canopy module.
+The OpenAI-compatible `/v1` paths, management `/api/v1` paths and scoped-token authentication are unchanged.

package/dist/canopy/v1/generated/functions.d.ts

@@ -2,21 +2,23 @@
  * Generated by orval 🍺
  * Do not edit manually.
  * Leaflow Canopy API
- * Management of API keys, together with the models available and the usage recorded against them.
+ * Canopy model inference, API keys, model catalogue, service enablement and recorded usage.
  *
- * **These endpoints do not perform inference.** Requests are issued to the forwarding address, which accepts the OpenAI, Anthropic and Gemini request formats:
+ * OpenAI-compatible project inference is served on this host at `/v1/chat/completions`,
+ * `/v1/embeddings`, `/v1/models` and `/v1/models/{model}`. Use `https://canopy.leaflow.cloud/v1`
+ * as the OpenAI SDK base URL. Chat completions support `stream=true` SSE.
  *
- * ```
- * POST /v1/chat/completions                    OpenAI
- * POST /v1/messages                            Anthropic
- * POST /v1beta/models/{model}:generateContent  Gemini
- * ```
+ * Management operations use `/api/v1`. The management model catalogue includes pricing;
+ * `/v1/models` returns the OpenAI model format with Canopy capabilities and parameter limits.
  *
  * ## Authentication
  *
  * Every request carries a scoped token; see the `bearerAuth` security scheme.
  *
- * These management endpoints do not accept a Canopy API key. On this userapi host, the OpenAI-compatible `/v1/chat/completions`, `/v1/embeddings`, `/v1/models` and `/v1/models/{model}` endpoints accept the same project token; see the project inference contract. The separate API-key gateway continues to accept Canopy API keys.
+ * Management and project inference accept the same verified IAM scoped token. The token is the
+ * sole billing project authority; `OpenAI-Project` and historical identity headers cannot
+ * override it. These endpoints do not accept a Canopy API key. The separate API-key gateway
+ * accepts Canopy API keys and supports OpenAI, Anthropic and Gemini request formats.
  *
  * ## Conventions
  *
@@ -28,13 +30,164 @@
  * - **The service is enabled before use.** A project enables the model platform once, through `create-service`; the forwarding endpoints refuse its requests until the service is `active`. Requests are then billed under the service's subscription by the tokens they use, at the rates stated in each model's `pricing`.
  * OpenAPI spec version: 1.0.0
  */
-import type { APIKeyResource, APIKeyUsageListResponseBody, ConflictResponse, CreateAPIKeyRequestBody, CreateServiceRequestBody, CreateServiceResponseBody, CursorPageRequestResource, Error, GetUsageSummaryParams, GetUsageTimelineParams, IssuedAPIKeyResource, LengthAwarePageAPIKeyResource, ListApiKeysParams, ListRequestsParams, ListUsageByApiKeyParams, ListUsageByModelParams, ModelListResponseBody, ModelResource, ModelUsageListResponseBody, Quote, RequestResource, ServiceResource, TotalsResource, UpdateAPIKeyRequestBody, UsageTimelineResponseBody } from "./models.js";
+import type { APIKeyResource, APIKeyUsageListResponseBody, ChatCompletion, ChatCompletionRequest, ConflictResponse, CreateAPIKeyRequestBody, CreateServiceRequestBody, CreateServiceResponseBody, CursorPageRequestResource, EmbeddingRequest, EmbeddingResponse, Error, GetUsageSummaryParams, GetUsageTimelineParams, InferenceError, IssuedAPIKeyResource, LengthAwarePageAPIKeyResource, ListApiKeysParams, ListRequestsParams, ListUsageByApiKeyParams, ListUsageByModelParams, Model, ModelList, ModelListResponseBody, ModelResource, ModelUsageListResponseBody, Quote, RequestResource, ResponseCreate, ResponseDeleted, ResponseResource, ServiceResource, TotalsResource, UpdateAPIKeyRequestBody, UsageTimelineResponseBody } from "./models.js";
 export type HTTPStatusCode1xx = 100 | 101 | 102 | 103;
 export type HTTPStatusCode2xx = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207;
 export type HTTPStatusCode3xx = 300 | 301 | 302 | 303 | 304 | 305 | 307 | 308;
 export type HTTPStatusCode4xx = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 | 420 | 421 | 422 | 423 | 424 | 426 | 428 | 429 | 431 | 451;
 export type HTTPStatusCode5xx = 500 | 501 | 502 | 503 | 504 | 505 | 507 | 511;
 export type HTTPStatusCodes = HTTPStatusCode1xx | HTTPStatusCode2xx | HTTPStatusCode3xx | HTTPStatusCode4xx | HTTPStatusCode5xx;
+export type createResponseResponse200ApplicationJson = {
+    data: ResponseResource;
+    status: 200;
+};
+export type createResponseResponse200TextEventStream = {
+    data: Blob;
+    status: 200;
+};
+export type createResponseResponseDefault = {
+    data: InferenceError;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type createResponseResponseSuccess = (createResponseResponse200ApplicationJson | createResponseResponse200TextEventStream) & {
+    headers: Headers;
+};
+export type createResponseResponseError = createResponseResponseDefault & {
+    headers: Headers;
+};
+export type createResponseResponse = createResponseResponseSuccess | createResponseResponseError;
+export declare const getCreateResponseUrl: () => string;
+/**
+ * Supports JSON, SSE and native upstream response storage. Stored continuation is restricted to the current project and original provider credential. WebSocket clients connect with GET /v1/responses and send response.create events; one response may be active on a connection at a time. The connection stays on its initial model and provider credential.
+ * @summary Create a model response
+ */
+export declare const createResponse: (responseCreate: ResponseCreate, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createResponseResponse>;
+export type getResponseResponse200 = {
+    data: ResponseResource;
+    status: 200;
+};
+export type getResponseResponseDefault = {
+    data: InferenceError;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getResponseResponseSuccess = getResponseResponse200 & {
+    headers: Headers;
+};
+export type getResponseResponseError = getResponseResponseDefault & {
+    headers: Headers;
+};
+export type getResponseResponse = getResponseResponseSuccess | getResponseResponseError;
+export declare const getGetResponseUrl: (response: string) => string;
+/**
+ * @summary Get a stored response
+ */
+export declare const getResponse: (response: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getResponseResponse>;
+export type deleteResponseResponse200 = {
+    data: ResponseDeleted;
+    status: 200;
+};
+export type deleteResponseResponseDefault = {
+    data: InferenceError;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type deleteResponseResponseSuccess = deleteResponseResponse200 & {
+    headers: Headers;
+};
+export type deleteResponseResponseError = deleteResponseResponseDefault & {
+    headers: Headers;
+};
+export type deleteResponseResponse = deleteResponseResponseSuccess | deleteResponseResponseError;
+export declare const getDeleteResponseUrl: (response: string) => string;
+/**
+ * @summary Delete a stored response
+ */
+export declare const deleteResponse: (response: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteResponseResponse>;
+export type createChatCompletionResponse200ApplicationJson = {
+    data: ChatCompletion;
+    status: 200;
+};
+export type createChatCompletionResponse200TextEventStream = {
+    data: Blob;
+    status: 200;
+};
+export type createChatCompletionResponseDefault = {
+    data: InferenceError;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type createChatCompletionResponseSuccess = (createChatCompletionResponse200ApplicationJson | createChatCompletionResponse200TextEventStream) & {
+    headers: Headers;
+};
+export type createChatCompletionResponseError = createChatCompletionResponseDefault & {
+    headers: Headers;
+};
+export type createChatCompletionResponse = createChatCompletionResponseSuccess | createChatCompletionResponseError;
+export declare const getCreateChatCompletionUrl: () => string;
+/**
+ * Authenticated project inference. Billing ownership comes only from the verified project token; no Canopy API key or project header is required.
+ * @summary Create a chat completion
+ */
+export declare const createChatCompletion: (chatCompletionRequest: ChatCompletionRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createChatCompletionResponse>;
+export type createEmbeddingsResponse200 = {
+    data: EmbeddingResponse;
+    status: 200;
+};
+export type createEmbeddingsResponseDefault = {
+    data: InferenceError;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type createEmbeddingsResponseSuccess = createEmbeddingsResponse200 & {
+    headers: Headers;
+};
+export type createEmbeddingsResponseError = createEmbeddingsResponseDefault & {
+    headers: Headers;
+};
+export type createEmbeddingsResponse = createEmbeddingsResponseSuccess | createEmbeddingsResponseError;
+export declare const getCreateEmbeddingsUrl: () => string;
+/**
+ * Authenticated project inference. Billing ownership comes only from the verified project token; no Canopy API key or project header is required.
+ * @summary Create embeddings
+ */
+export declare const createEmbeddings: (embeddingRequest: EmbeddingRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createEmbeddingsResponse>;
+export type listInferenceModelsResponse200 = {
+    data: ModelList;
+    status: 200;
+};
+export type listInferenceModelsResponseDefault = {
+    data: InferenceError;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listInferenceModelsResponseSuccess = listInferenceModelsResponse200 & {
+    headers: Headers;
+};
+export type listInferenceModelsResponseError = listInferenceModelsResponseDefault & {
+    headers: Headers;
+};
+export type listInferenceModelsResponse = listInferenceModelsResponseSuccess | listInferenceModelsResponseError;
+export declare const getListInferenceModelsUrl: () => string;
+/**
+ * @summary List callable models with capabilities and parameter limits
+ */
+export declare const listInferenceModels: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listInferenceModelsResponse>;
+export type getInferenceModelResponse200 = {
+    data: Model;
+    status: 200;
+};
+export type getInferenceModelResponseDefault = {
+    data: InferenceError;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getInferenceModelResponseSuccess = getInferenceModelResponse200 & {
+    headers: Headers;
+};
+export type getInferenceModelResponseError = getInferenceModelResponseDefault & {
+    headers: Headers;
+};
+export type getInferenceModelResponse = getInferenceModelResponseSuccess | getInferenceModelResponseError;
+export declare const getGetInferenceModelUrl: (model: string) => string;
+/**
+ * @summary Get a callable model with capabilities and parameter limits
+ */
+export declare const getInferenceModel: (model: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getInferenceModelResponse>;
 export type listApiKeysResponse200 = {
     data: LengthAwarePageAPIKeyResource;
     status: 200;

package/dist/canopy/v1/generated/functions.js

@@ -1,3 +1,170 @@
+export const getCreateResponseUrl = () => {
+    return `https://canopy.leaflow.cloud/v1/responses`;
+};
+/**
+ * Supports JSON, SSE and native upstream response storage. Stored continuation is restricted to the current project and original provider credential. WebSocket clients connect with GET /v1/responses and send response.create events; one response may be active on a connection at a time. The connection stays on its initial model and provider credential.
+ * @summary Create a model response
+ */
+export const createResponse = async (responseCreate, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateResponseUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(responseCreate),
+    });
+    const body = [204, 205, 304].includes(res.status)
+        ? null
+        : res.headers.get("content-type")?.includes("application/json")
+            ? JSON.parse(await res.text())
+            : await res.blob();
+    const data = body;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetResponseUrl = (response) => {
+    return `https://canopy.leaflow.cloud/v1/responses/${encodeURIComponent(String(response))}`;
+};
+/**
+ * @summary Get a stored response
+ */
+export const getResponse = async (response, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetResponseUrl(response), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteResponseUrl = (response) => {
+    return `https://canopy.leaflow.cloud/v1/responses/${encodeURIComponent(String(response))}`;
+};
+/**
+ * @summary Delete a stored response
+ */
+export const deleteResponse = async (response, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteResponseUrl(response), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateChatCompletionUrl = () => {
+    return `https://canopy.leaflow.cloud/v1/chat/completions`;
+};
+/**
+ * Authenticated project inference. Billing ownership comes only from the verified project token; no Canopy API key or project header is required.
+ * @summary Create a chat completion
+ */
+export const createChatCompletion = async (chatCompletionRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateChatCompletionUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(chatCompletionRequest),
+    });
+    const body = [204, 205, 304].includes(res.status)
+        ? null
+        : res.headers.get("content-type")?.includes("application/json")
+            ? JSON.parse(await res.text())
+            : await res.blob();
+    const data = body;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateEmbeddingsUrl = () => {
+    return `https://canopy.leaflow.cloud/v1/embeddings`;
+};
+/**
+ * Authenticated project inference. Billing ownership comes only from the verified project token; no Canopy API key or project header is required.
+ * @summary Create embeddings
+ */
+export const createEmbeddings = async (embeddingRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateEmbeddingsUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(embeddingRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListInferenceModelsUrl = () => {
+    return `https://canopy.leaflow.cloud/v1/models`;
+};
+/**
+ * @summary List callable models with capabilities and parameter limits
+ */
+export const listInferenceModels = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListInferenceModelsUrl(), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetInferenceModelUrl = (model) => {
+    return `https://canopy.leaflow.cloud/v1/models/${encodeURIComponent(String(model))}`;
+};
+/**
+ * @summary Get a callable model with capabilities and parameter limits
+ */
+export const getInferenceModel = async (model, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetInferenceModelUrl(model), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
 export const getListApiKeysUrl = (params) => {
     const normalizedParams = new URLSearchParams();
     Object.entries(params || {}).forEach(([key, value]) => {

package/dist/canopy/v1/generated/models.d.ts

@@ -2,21 +2,23 @@
  * Generated by orval 🍺
  * Do not edit manually.
  * Leaflow Canopy API
- * Management of API keys, together with the models available and the usage recorded against them.
+ * Canopy model inference, API keys, model catalogue, service enablement and recorded usage.
  *
- * **These endpoints do not perform inference.** Requests are issued to the forwarding address, which accepts the OpenAI, Anthropic and Gemini request formats:
+ * OpenAI-compatible project inference is served on this host at `/v1/chat/completions`,
+ * `/v1/embeddings`, `/v1/models` and `/v1/models/{model}`. Use `https://canopy.leaflow.cloud/v1`
+ * as the OpenAI SDK base URL. Chat completions support `stream=true` SSE.
  *
- * ```
- * POST /v1/chat/completions                    OpenAI
- * POST /v1/messages                            Anthropic
- * POST /v1beta/models/{model}:generateContent  Gemini
- * ```
+ * Management operations use `/api/v1`. The management model catalogue includes pricing;
+ * `/v1/models` returns the OpenAI model format with Canopy capabilities and parameter limits.
  *
  * ## Authentication
  *
  * Every request carries a scoped token; see the `bearerAuth` security scheme.
  *
- * These management endpoints do not accept a Canopy API key. On this userapi host, the OpenAI-compatible `/v1/chat/completions`, `/v1/embeddings`, `/v1/models` and `/v1/models/{model}` endpoints accept the same project token; see the project inference contract. The separate API-key gateway continues to accept Canopy API keys.
+ * Management and project inference accept the same verified IAM scoped token. The token is the
+ * sole billing project authority; `OpenAI-Project` and historical identity headers cannot
+ * override it. These endpoints do not accept a Canopy API key. The separate API-key gateway
+ * accepts Canopy API keys and supports OpenAI, Anthropic and Gemini request formats.
  *
  * ## Conventions
  *
@@ -28,6 +30,161 @@
  * - **The service is enabled before use.** A project enables the model platform once, through `create-service`; the forwarding endpoints refuse its requests until the service is `active`. Requests are then billed under the service's subscription by the tokens they use, at the rates stated in each model's `pricing`.
  * OpenAPI spec version: 1.0.0
  */
+export type ReasoningDiagnosticsRequested = {
+    [key: string]: unknown;
+};
+export type ReasoningDiagnosticsEffective = {
+    [key: string]: unknown;
+};
+export type ReasoningDiagnosticsTranslation = (typeof ReasoningDiagnosticsTranslation)[keyof typeof ReasoningDiagnosticsTranslation];
+export declare const ReasoningDiagnosticsTranslation: {
+    readonly translate: "translate";
+    readonly passthrough: "passthrough";
+    readonly strip: "strip";
+};
+export interface ReasoningDiagnostics {
+    requested: ReasoningDiagnosticsRequested;
+    effective?: ReasoningDiagnosticsEffective;
+    translation?: ReasoningDiagnosticsTranslation;
+}
+export type ChatCompletionRequestMessagesItem = {
+    [key: string]: unknown;
+};
+export interface ChatCompletionRequest {
+    /** @minLength 1 */
+    model: string;
+    /** @minItems 1 */
+    messages: ChatCompletionRequestMessagesItem[];
+    stream?: boolean;
+    /** @minimum 1 */
+    max_tokens?: number;
+    /** @minimum 1 */
+    max_completion_tokens?: number;
+    reasoning_effort?: string;
+    [key: string]: unknown;
+}
+export interface ChatCompletion {
+    [key: string]: unknown;
+}
+export type EmbeddingRequestEncodingFormat = (typeof EmbeddingRequestEncodingFormat)[keyof typeof EmbeddingRequestEncodingFormat];
+export declare const EmbeddingRequestEncodingFormat: {
+    readonly float: "float";
+    readonly base64: "base64";
+};
+export interface EmbeddingRequest {
+    /** @minLength 1 */
+    model: string;
+    /** A nonempty string, string array, token integer array, or array of token integer arrays. */
+    input: string | unknown[];
+    encoding_format?: EmbeddingRequestEncodingFormat;
+    /** @minimum 1 */
+    dimensions?: number;
+    user?: string;
+    [key: string]: unknown;
+}
+export interface EmbeddingResponse {
+    [key: string]: unknown;
+}
+export type Modality = (typeof Modality)[keyof typeof Modality];
+export declare const Modality: {
+    readonly text: "text";
+    readonly image: "image";
+    readonly audio: "audio";
+    readonly video: "video";
+    readonly file: "file";
+    readonly embedding: "embedding";
+};
+/**
+ * @nullable
+ */
+export type ReasoningCapabilitiesBudgetTokens = {
+    /** @minimum 0 */
+    min: number;
+    /** @minimum 0 */
+    max: number;
+} | null;
+export interface ReasoningCapabilities {
+    supported: boolean;
+    /**
+     * Null means unknown; an empty array means effort is not configurable.
+     * @nullable
+     */
+    effort_levels: string[] | null;
+    /** @nullable */
+    default_effort: string | null;
+    /** @nullable */
+    modes: string[] | null;
+    /** @nullable */
+    budget_tokens: ReasoningCapabilitiesBudgetTokens;
+    /** @nullable */
+    summary: string[] | null;
+}
+export interface EndpointCapabilities {
+    /** @nullable */
+    function_calling: boolean | null;
+    /** @nullable */
+    structured_output: boolean | null;
+    reasoning: ReasoningCapabilities | null;
+}
+/**
+ * Verified capabilities keyed by API endpoint, for example /v1/chat/completions or /v1/responses. Missing keys and null values mean unknown. Current route availability is separate.
+ */
+export interface ModelCapabilities {
+    [key: string]: EndpointCapabilities;
+}
+export type ModelEndpoint = (typeof ModelEndpoint)[keyof typeof ModelEndpoint];
+export declare const ModelEndpoint: {
+    readonly "/v1/chat/completions": "/v1/chat/completions";
+    readonly "/v1/responses": "/v1/responses";
+    readonly "/v1/embeddings": "/v1/embeddings";
+    readonly "/v1/images/generations": "/v1/images/generations";
+    readonly "/v1/images/edits": "/v1/images/edits";
+    readonly "/v1/audio/transcriptions": "/v1/audio/transcriptions";
+    readonly "/v1/audio/translations": "/v1/audio/translations";
+    readonly "/v1/audio/speech": "/v1/audio/speech";
+    readonly "/v1/realtime": "/v1/realtime";
+};
+export interface Model {
+    id: string;
+    object: "model";
+    created: number;
+    owned_by: string;
+    display_name: string;
+    context_length: number;
+    max_output_tokens: number;
+    /** The model developer; not the upstream provider or model family. */
+    developer: string;
+    description: string;
+    /**
+     * Accepted input modalities. Null means unknown.
+     * @nullable
+     */
+    input_modalities: Modality[] | null;
+    /**
+     * Produced output modalities. Image input does not imply image generation.
+     * @nullable
+     */
+    output_modalities: Modality[] | null;
+    capabilities: ModelCapabilities;
+    /** Explicitly supported API endpoints. Requests to any other endpoint are rejected before upstream admission. */
+    supported_endpoints: ModelEndpoint[];
+}
+export interface ModelList {
+    object: "list";
+    data: Model[];
+}
+export type InferenceErrorError = {
+    message: string;
+    type: string;
+    /** @nullable */
+    param?: string | null;
+    /** @nullable */
+    code?: string | null;
+    [key: string]: unknown;
+};
+export interface InferenceError {
+    error: InferenceErrorError;
+}
 /**
  * What a given `code` carries alongside the message. The keys depend on the code,
  * and a client that does not recognise one ignores it.
@@ -221,12 +378,23 @@ export interface ModelResource {
     max_output_tokens: number;
     /** What requests to this model cost. Null when the project has no billing account. */
     pricing: ModelPricing | null;
-    /** The values accepted for `reasoning_effort`. Empty means it is not supported */
-    reasoning_tiers: string[];
     status: ModelResourceStatus;
-    supports_reasoning: boolean;
-    supports_tools: boolean;
-    supports_vision: boolean;
+    /** The model developer; not the upstream provider or model family. */
+    developer: string;
+    description: string;
+    /**
+     * Accepted input modalities. Null means unknown.
+     * @nullable
+     */
+    input_modalities: Modality[] | null;
+    /**
+     * Produced output modalities. Image input does not imply image generation.
+     * @nullable
+     */
+    output_modalities: Modality[] | null;
+    capabilities: ModelCapabilities;
+    /** Explicitly supported API endpoints. Requests to any other endpoint are rejected before upstream admission. */
+    supported_endpoints: ModelEndpoint[];
 }
 export interface ModelListResponseBody {
     items: ModelResource[];
@@ -279,6 +447,7 @@ export interface RequestResource {
     upstream_status: number;
     /** upstream means the figures were reported by the provider; estimated means they were derived from the character classes of the payload */
     usage_source: RequestResourceUsageSource;
+    reasoning: ReasoningDiagnostics | null;
 }
 export interface CursorPageRequestResource {
     /** The items in this page */
@@ -590,6 +759,38 @@ export interface Quote {
      */
     refundable_amount: Money | null;
 }
+export type ResponseCreateReasoning = {
+    [key: string]: unknown;
+};
+export type ResponseCreateToolsItem = {
+    [key: string]: unknown;
+};
+/**
+ * Native Responses request. model may be omitted when continuing a project-owned stored response. store defaults to false. Only caller-executed function and custom tools are supported. background, conversation and WebSocket-only fields are rejected over HTTP.
+ */
+export interface ResponseCreate {
+    model?: string;
+    input?: unknown;
+    /** @nullable */
+    instructions?: string | null;
+    store?: boolean;
+    stream?: boolean;
+    /** @nullable */
+    previous_response_id?: string | null;
+    reasoning?: ResponseCreateReasoning;
+    tools?: ResponseCreateToolsItem[];
+    /** @minimum 1 */
+    max_output_tokens?: number;
+    [key: string]: unknown;
+}
+export interface ResponseResource {
+    [key: string]: unknown;
+}
+export interface ResponseDeleted {
+    id: string;
+    object: string;
+    deleted: boolean;
+}
 /**
  * Pagination metadata for stable numbered pages. total_count is returned only when the operation can determine it without an unbounded scan.
  */