@openrouter/sdk 0.11.2 → 0.12.0

package/esm/models/providerpreferences.js

@@ -5,147 +5,101 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import * as openEnums from "../types/enums.js";
-import { DataCollection$outboundSchema, } from "./datacollection.js";
 import { PreferredMaxLatency$outboundSchema, } from "./preferredmaxlatency.js";
 import { PreferredMinThroughput$outboundSchema, } from "./preferredminthroughput.js";
 import { ProviderName$outboundSchema } from "./providername.js";
+import { ProviderSort$outboundSchema } from "./providersort.js";
+import { ProviderSortConfig$outboundSchema, } from "./providersortconfig.js";
 import { Quantization$outboundSchema } from "./quantization.js";
-export const ProviderPreferencesSortEnum = {
-    Price: "price",
-    Throughput: "throughput",
-    Latency: "latency",
-    Exacto: "exacto",
-};
-export const ProviderPreferencesProviderSortConfigEnum = {
-    Price: "price",
-    Throughput: "throughput",
-    Latency: "latency",
-    Exacto: "exacto",
-};
-/**
- * The provider sorting strategy (price, throughput, latency)
- */
-export const ProviderPreferencesBy = {
-    Price: "price",
-    Throughput: "throughput",
-    Latency: "latency",
-    Exacto: "exacto",
-};
-/**
- * Partitioning strategy for sorting: "model" (default) groups endpoints by model before sorting (fallback models remain fallbacks), "none" sorts all endpoints together regardless of model.
- */
-export const ProviderPreferencesPartition = {
-    Model: "model",
-    None: "none",
-};
 /**
- * The provider sorting strategy (price, throughput, latency)
+ * Data collection setting. If no available model provider meets the requirement, your request will return an error.
+ *
+ * @remarks
+ * - allow: (default) allow providers which store user data non-transiently and may train on it
+ *
+ * - deny: use only providers which do not collect user data.
  */
-export const ProviderPreferencesProviderSort = {
-    Price: "price",
-    Throughput: "throughput",
-    Latency: "latency",
-    Exacto: "exacto",
+export const DataCollection = {
+    Deny: "deny",
+    Allow: "allow",
 };
 /** @internal */
-export const ProviderPreferencesOrder$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
-export function providerPreferencesOrderToJSON(providerPreferencesOrder) {
-    return JSON.stringify(ProviderPreferencesOrder$outboundSchema.parse(providerPreferencesOrder));
-}
-/** @internal */
-export const ProviderPreferencesOnly$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
-export function providerPreferencesOnlyToJSON(providerPreferencesOnly) {
-    return JSON.stringify(ProviderPreferencesOnly$outboundSchema.parse(providerPreferencesOnly));
-}
+export const DataCollection$outboundSchema = openEnums.outboundSchema(DataCollection);
 /** @internal */
-export const ProviderPreferencesIgnore$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
-export function providerPreferencesIgnoreToJSON(providerPreferencesIgnore) {
-    return JSON.stringify(ProviderPreferencesIgnore$outboundSchema.parse(providerPreferencesIgnore));
+export const Ignore$outboundSchema = z
+    .union([ProviderName$outboundSchema, z.string()]);
+export function ignoreToJSON(ignore) {
+    return JSON.stringify(Ignore$outboundSchema.parse(ignore));
 }
 /** @internal */
-export const ProviderPreferencesSortEnum$outboundSchema = openEnums.outboundSchema(ProviderPreferencesSortEnum);
-/** @internal */
-export const ProviderPreferencesProviderSortConfigEnum$outboundSchema = z.enum(ProviderPreferencesProviderSortConfigEnum);
-/** @internal */
-export const ProviderPreferencesBy$outboundSchema = openEnums.outboundSchema(ProviderPreferencesBy);
-/** @internal */
-export const ProviderPreferencesPartition$outboundSchema = openEnums.outboundSchema(ProviderPreferencesPartition);
-/** @internal */
-export const ProviderPreferencesProviderSortConfig$outboundSchema = z.object({
-    by: z.nullable(ProviderPreferencesBy$outboundSchema).optional(),
-    partition: z.nullable(ProviderPreferencesPartition$outboundSchema).optional(),
+export const MaxPrice$outboundSchema = z
+    .object({
+    audio: z.string().optional(),
+    completion: z.string().optional(),
+    image: z.string().optional(),
+    prompt: z.string().optional(),
+    request: z.string().optional(),
 });
-export function providerPreferencesProviderSortConfigToJSON(providerPreferencesProviderSortConfig) {
-    return JSON.stringify(ProviderPreferencesProviderSortConfig$outboundSchema.parse(providerPreferencesProviderSortConfig));
+export function maxPriceToJSON(maxPrice) {
+    return JSON.stringify(MaxPrice$outboundSchema.parse(maxPrice));
 }
 /** @internal */
-export const ProviderPreferencesProviderSortConfigUnion$outboundSchema = z.union([
-    z.lazy(() => ProviderPreferencesProviderSortConfig$outboundSchema),
-    ProviderPreferencesProviderSortConfigEnum$outboundSchema,
+export const Only$outboundSchema = z.union([
+    ProviderName$outboundSchema,
+    z.string(),
 ]);
-export function providerPreferencesProviderSortConfigUnionToJSON(providerPreferencesProviderSortConfigUnion) {
-    return JSON.stringify(ProviderPreferencesProviderSortConfigUnion$outboundSchema.parse(providerPreferencesProviderSortConfigUnion));
+export function onlyToJSON(only) {
+    return JSON.stringify(Only$outboundSchema.parse(only));
 }
 /** @internal */
-export const ProviderPreferencesProviderSort$outboundSchema = openEnums.outboundSchema(ProviderPreferencesProviderSort);
-/** @internal */
-export const ProviderPreferencesSortUnion$outboundSchema = z.union([
-    ProviderPreferencesProviderSort$outboundSchema,
-    z.union([
-        z.lazy(() => ProviderPreferencesProviderSortConfig$outboundSchema),
-        ProviderPreferencesProviderSortConfigEnum$outboundSchema,
-    ]),
-    ProviderPreferencesSortEnum$outboundSchema,
+export const Order$outboundSchema = z.union([
+    ProviderName$outboundSchema,
+    z.string(),
 ]);
-export function providerPreferencesSortUnionToJSON(providerPreferencesSortUnion) {
-    return JSON.stringify(ProviderPreferencesSortUnion$outboundSchema.parse(providerPreferencesSortUnion));
+export function orderToJSON(order) {
+    return JSON.stringify(Order$outboundSchema.parse(order));
 }
 /** @internal */
-export const ProviderPreferencesMaxPrice$outboundSchema = z.object({
-    prompt: z.string().optional(),
-    completion: z.string().optional(),
-    image: z.string().optional(),
-    audio: z.string().optional(),
-    request: z.string().optional(),
-});
-export function providerPreferencesMaxPriceToJSON(providerPreferencesMaxPrice) {
-    return JSON.stringify(ProviderPreferencesMaxPrice$outboundSchema.parse(providerPreferencesMaxPrice));
+export const Sort$outboundSchema = z.union([
+    ProviderSort$outboundSchema,
+    ProviderSortConfig$outboundSchema,
+    z.any(),
+]);
+export function sortToJSON(sort) {
+    return JSON.stringify(Sort$outboundSchema.parse(sort));
 }
 /** @internal */
 export const ProviderPreferences$outboundSchema = z.object({
     allowFallbacks: z.nullable(z.boolean()).optional(),
-    requireParameters: z.nullable(z.boolean()).optional(),
     dataCollection: z.nullable(DataCollection$outboundSchema).optional(),
-    zdr: z.nullable(z.boolean()).optional(),
     enforceDistillableText: z.nullable(z.boolean()).optional(),
+    ignore: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()]))).optional(),
+    maxPrice: z.lazy(() => MaxPrice$outboundSchema).optional(),
+    only: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()])))
+        .optional(),
     order: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()])))
         .optional(),
-    only: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()])))
+    preferredMaxLatency: z.nullable(PreferredMaxLatency$outboundSchema)
+        .optional(),
+    preferredMinThroughput: z.nullable(PreferredMinThroughput$outboundSchema)
         .optional(),
-    ignore: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()]))).optional(),
     quantizations: z.nullable(z.array(Quantization$outboundSchema)).optional(),
+    requireParameters: z.nullable(z.boolean()).optional(),
     sort: z.nullable(z.union([
-        ProviderPreferencesProviderSort$outboundSchema,
-        z.union([
-            z.lazy(() => ProviderPreferencesProviderSortConfig$outboundSchema),
-            ProviderPreferencesProviderSortConfigEnum$outboundSchema,
-        ]),
-        ProviderPreferencesSortEnum$outboundSchema,
+        ProviderSort$outboundSchema,
+        ProviderSortConfig$outboundSchema,
+        z.any(),
     ])).optional(),
-    maxPrice: z.lazy(() => ProviderPreferencesMaxPrice$outboundSchema).optional(),
-    preferredMinThroughput: z.nullable(PreferredMinThroughput$outboundSchema)
-        .optional(),
-    preferredMaxLatency: z.nullable(PreferredMaxLatency$outboundSchema)
-        .optional(),
+    zdr: z.nullable(z.boolean()).optional(),
 }).transform((v) => {
     return remap$(v, {
         allowFallbacks: "allow_fallbacks",
-        requireParameters: "require_parameters",
         dataCollection: "data_collection",
         enforceDistillableText: "enforce_distillable_text",
         maxPrice: "max_price",
-        preferredMinThroughput: "preferred_min_throughput",
         preferredMaxLatency: "preferred_max_latency",
+        preferredMinThroughput: "preferred_min_throughput",
+        requireParameters: "require_parameters",
     });
 });
 export function providerPreferencesToJSON(providerPreferences) {

package/esm/models/providerresponse.d.ts

@@ -0,0 +1,156 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Name of the provider
+ */
+export declare const ProviderResponseProviderName: {
+    readonly AnyScale: "AnyScale";
+    readonly Atoma: "Atoma";
+    readonly CentML: "Cent-ML";
+    readonly CrofAI: "CrofAI";
+    readonly Enfer: "Enfer";
+    readonly GoPomelo: "GoPomelo";
+    readonly HuggingFace: "HuggingFace";
+    readonly Hyperbolic2: "Hyperbolic 2";
+    readonly InoCloud: "InoCloud";
+    readonly Kluster: "Kluster";
+    readonly Lambda: "Lambda";
+    readonly Lepton: "Lepton";
+    readonly Lynn2: "Lynn 2";
+    readonly Lynn: "Lynn";
+    readonly Mancer: "Mancer";
+    readonly Meta: "Meta";
+    readonly Modal: "Modal";
+    readonly Nineteen: "Nineteen";
+    readonly OctoAI: "OctoAI";
+    readonly Recursal: "Recursal";
+    readonly Reflection: "Reflection";
+    readonly Replicate: "Replicate";
+    readonly SambaNova2: "SambaNova 2";
+    readonly SFCompute: "SF Compute";
+    readonly Targon: "Targon";
+    readonly Together2: "Together 2";
+    readonly Ubicloud: "Ubicloud";
+    readonly OneDotAI: "01.AI";
+    readonly AkashML: "AkashML";
+    readonly Ai21: "AI21";
+    readonly AionLabs: "AionLabs";
+    readonly Alibaba: "Alibaba";
+    readonly Ambient: "Ambient";
+    readonly AmazonBedrock: "Amazon Bedrock";
+    readonly AmazonNova: "Amazon Nova";
+    readonly Anthropic: "Anthropic";
+    readonly ArceeAI: "Arcee AI";
+    readonly AtlasCloud: "AtlasCloud";
+    readonly Avian: "Avian";
+    readonly Azure: "Azure";
+    readonly BaseTen: "BaseTen";
+    readonly BytePlus: "BytePlus";
+    readonly BlackForestLabs: "Black Forest Labs";
+    readonly Cerebras: "Cerebras";
+    readonly Chutes: "Chutes";
+    readonly Cirrascale: "Cirrascale";
+    readonly Clarifai: "Clarifai";
+    readonly Cloudflare: "Cloudflare";
+    readonly Cohere: "Cohere";
+    readonly Crusoe: "Crusoe";
+    readonly DeepInfra: "DeepInfra";
+    readonly DeepSeek: "DeepSeek";
+    readonly Featherless: "Featherless";
+    readonly Fireworks: "Fireworks";
+    readonly Friendli: "Friendli";
+    readonly GMICloud: "GMICloud";
+    readonly Google: "Google";
+    readonly GoogleAIStudio: "Google AI Studio";
+    readonly Groq: "Groq";
+    readonly Hyperbolic: "Hyperbolic";
+    readonly Inception: "Inception";
+    readonly Inceptron: "Inceptron";
+    readonly InferenceNet: "InferenceNet";
+    readonly Ionstream: "Ionstream";
+    readonly Infermatic: "Infermatic";
+    readonly IoNet: "Io Net";
+    readonly Inflection: "Inflection";
+    readonly Liquid: "Liquid";
+    readonly Mara: "Mara";
+    readonly Mancer2: "Mancer 2";
+    readonly Minimax: "Minimax";
+    readonly ModelRun: "ModelRun";
+    readonly Mistral: "Mistral";
+    readonly Modular: "Modular";
+    readonly MoonshotAI: "Moonshot AI";
+    readonly Morph: "Morph";
+    readonly NCompass: "NCompass";
+    readonly Nebius: "Nebius";
+    readonly NextBit: "NextBit";
+    readonly Novita: "Novita";
+    readonly Nvidia: "Nvidia";
+    readonly OpenAI: "OpenAI";
+    readonly OpenInference: "OpenInference";
+    readonly Parasail: "Parasail";
+    readonly Perplexity: "Perplexity";
+    readonly Phala: "Phala";
+    readonly Reka: "Reka";
+    readonly Relace: "Relace";
+    readonly SambaNova: "SambaNova";
+    readonly Seed: "Seed";
+    readonly SiliconFlow: "SiliconFlow";
+    readonly Sourceful: "Sourceful";
+    readonly StepFun: "StepFun";
+    readonly Stealth: "Stealth";
+    readonly StreamLake: "StreamLake";
+    readonly Switchpoint: "Switchpoint";
+    readonly Together: "Together";
+    readonly Upstage: "Upstage";
+    readonly Venice: "Venice";
+    readonly WandB: "WandB";
+    readonly Xiaomi: "Xiaomi";
+    readonly XAI: "xAI";
+    readonly ZAi: "Z.AI";
+    readonly FakeProvider: "FakeProvider";
+};
+/**
+ * Name of the provider
+ */
+export type ProviderResponseProviderName = OpenEnum<typeof ProviderResponseProviderName>;
+/**
+ * Details of a provider response for a generation attempt
+ */
+export type ProviderResponse = {
+    /**
+     * Internal endpoint identifier
+     */
+    endpointId?: string | undefined;
+    /**
+     * Upstream provider response identifier
+     */
+    id?: string | undefined;
+    /**
+     * Whether the request used a bring-your-own-key
+     */
+    isByok?: boolean | undefined;
+    /**
+     * Response latency in milliseconds
+     */
+    latency?: number | undefined;
+    /**
+     * Canonical model slug
+     */
+    modelPermaslug?: string | undefined;
+    /**
+     * Name of the provider
+     */
+    providerName?: ProviderResponseProviderName | undefined;
+    /**
+     * HTTP status code from the provider
+     */
+    status: number | null;
+};
+/** @internal */
+export declare const ProviderResponseProviderName$inboundSchema: z.ZodType<ProviderResponseProviderName, unknown>;
+/** @internal */
+export declare const ProviderResponse$inboundSchema: z.ZodType<ProviderResponse, unknown>;
+export declare function providerResponseFromJSON(jsonString: string): SafeParseResult<ProviderResponse, SDKValidationError>;
+//# sourceMappingURL=providerresponse.d.ts.map

package/esm/models/providerresponse.js

@@ -0,0 +1,140 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7427d17a27bc
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+/**
+ * Name of the provider
+ */
+export const ProviderResponseProviderName = {
+    AnyScale: "AnyScale",
+    Atoma: "Atoma",
+    CentML: "Cent-ML",
+    CrofAI: "CrofAI",
+    Enfer: "Enfer",
+    GoPomelo: "GoPomelo",
+    HuggingFace: "HuggingFace",
+    Hyperbolic2: "Hyperbolic 2",
+    InoCloud: "InoCloud",
+    Kluster: "Kluster",
+    Lambda: "Lambda",
+    Lepton: "Lepton",
+    Lynn2: "Lynn 2",
+    Lynn: "Lynn",
+    Mancer: "Mancer",
+    Meta: "Meta",
+    Modal: "Modal",
+    Nineteen: "Nineteen",
+    OctoAI: "OctoAI",
+    Recursal: "Recursal",
+    Reflection: "Reflection",
+    Replicate: "Replicate",
+    SambaNova2: "SambaNova 2",
+    SFCompute: "SF Compute",
+    Targon: "Targon",
+    Together2: "Together 2",
+    Ubicloud: "Ubicloud",
+    OneDotAI: "01.AI",
+    AkashML: "AkashML",
+    Ai21: "AI21",
+    AionLabs: "AionLabs",
+    Alibaba: "Alibaba",
+    Ambient: "Ambient",
+    AmazonBedrock: "Amazon Bedrock",
+    AmazonNova: "Amazon Nova",
+    Anthropic: "Anthropic",
+    ArceeAI: "Arcee AI",
+    AtlasCloud: "AtlasCloud",
+    Avian: "Avian",
+    Azure: "Azure",
+    BaseTen: "BaseTen",
+    BytePlus: "BytePlus",
+    BlackForestLabs: "Black Forest Labs",
+    Cerebras: "Cerebras",
+    Chutes: "Chutes",
+    Cirrascale: "Cirrascale",
+    Clarifai: "Clarifai",
+    Cloudflare: "Cloudflare",
+    Cohere: "Cohere",
+    Crusoe: "Crusoe",
+    DeepInfra: "DeepInfra",
+    DeepSeek: "DeepSeek",
+    Featherless: "Featherless",
+    Fireworks: "Fireworks",
+    Friendli: "Friendli",
+    GMICloud: "GMICloud",
+    Google: "Google",
+    GoogleAIStudio: "Google AI Studio",
+    Groq: "Groq",
+    Hyperbolic: "Hyperbolic",
+    Inception: "Inception",
+    Inceptron: "Inceptron",
+    InferenceNet: "InferenceNet",
+    Ionstream: "Ionstream",
+    Infermatic: "Infermatic",
+    IoNet: "Io Net",
+    Inflection: "Inflection",
+    Liquid: "Liquid",
+    Mara: "Mara",
+    Mancer2: "Mancer 2",
+    Minimax: "Minimax",
+    ModelRun: "ModelRun",
+    Mistral: "Mistral",
+    Modular: "Modular",
+    MoonshotAI: "Moonshot AI",
+    Morph: "Morph",
+    NCompass: "NCompass",
+    Nebius: "Nebius",
+    NextBit: "NextBit",
+    Novita: "Novita",
+    Nvidia: "Nvidia",
+    OpenAI: "OpenAI",
+    OpenInference: "OpenInference",
+    Parasail: "Parasail",
+    Perplexity: "Perplexity",
+    Phala: "Phala",
+    Reka: "Reka",
+    Relace: "Relace",
+    SambaNova: "SambaNova",
+    Seed: "Seed",
+    SiliconFlow: "SiliconFlow",
+    Sourceful: "Sourceful",
+    StepFun: "StepFun",
+    Stealth: "Stealth",
+    StreamLake: "StreamLake",
+    Switchpoint: "Switchpoint",
+    Together: "Together",
+    Upstage: "Upstage",
+    Venice: "Venice",
+    WandB: "WandB",
+    Xiaomi: "Xiaomi",
+    XAI: "xAI",
+    ZAi: "Z.AI",
+    FakeProvider: "FakeProvider",
+};
+/** @internal */
+export const ProviderResponseProviderName$inboundSchema = openEnums.inboundSchema(ProviderResponseProviderName);
+/** @internal */
+export const ProviderResponse$inboundSchema = z.object({
+    endpoint_id: z.string().optional(),
+    id: z.string().optional(),
+    is_byok: z.boolean().optional(),
+    latency: z.number().optional(),
+    model_permaslug: z.string().optional(),
+    provider_name: ProviderResponseProviderName$inboundSchema.optional(),
+    status: z.nullable(z.number()),
+}).transform((v) => {
+    return remap$(v, {
+        "endpoint_id": "endpointId",
+        "is_byok": "isByok",
+        "model_permaslug": "modelPermaslug",
+        "provider_name": "providerName",
+    });
+});
+export function providerResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ProviderResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ProviderResponse' from JSON`);
+}
+//# sourceMappingURL=providerresponse.js.map

package/esm/models/publicendpoint.d.ts

@@ -7,20 +7,20 @@ import { Parameter } from "./parameter.js";
 import { PercentileStats } from "./percentilestats.js";
 import { ProviderName } from "./providername.js";
 export type Pricing = {
-    prompt: string;
+    audio?: string | undefined;
+    audioOutput?: string | undefined;
     completion: string;
-    request?: string | undefined;
+    discount?: number | undefined;
     image?: string | undefined;
-    imageToken?: string | undefined;
     imageOutput?: string | undefined;
-    audio?: string | undefined;
-    audioOutput?: string | undefined;
+    imageToken?: string | undefined;
     inputAudioCache?: string | undefined;
-    webSearch?: string | undefined;
-    internalReasoning?: string | undefined;
     inputCacheRead?: string | undefined;
     inputCacheWrite?: string | undefined;
-    discount?: number | undefined;
+    internalReasoning?: string | undefined;
+    prompt: string;
+    request?: string | undefined;
+    webSearch?: string | undefined;
 };
 export declare const PublicEndpointQuantization: {
     readonly Int4: "int4";
@@ -38,28 +38,36 @@ export type PublicEndpointQuantization = OpenEnum<typeof PublicEndpointQuantizat
  * Information about a specific model endpoint
  */
 export type PublicEndpoint = {
-    name: string;
+    contextLength: number;
+    /**
+     * Latency percentiles in milliseconds over the last 30 minutes. Latency measures time to first token. Only visible when authenticated with an API key or cookie; returns null for unauthenticated requests.
+     */
+    latencyLast30m: PercentileStats | null;
+    maxCompletionTokens: number;
+    maxPromptTokens: number;
     /**
      * The unique identifier for the model (permaslug)
      */
     modelId: string;
     modelName: string;
-    contextLength: number;
+    name: string;
     pricing: Pricing;
     providerName: ProviderName;
-    tag: string;
     quantization: PublicEndpointQuantization | null;
-    maxCompletionTokens: number | null;
-    maxPromptTokens: number | null;
-    supportedParameters: Array<Parameter>;
     status?: EndpointStatus | undefined;
-    uptimeLast30m: number | null;
+    supportedParameters: Array<Parameter>;
     supportsImplicitCaching: boolean;
+    tag: string;
+    throughputLast30m: PercentileStats | null;
     /**
-     * Latency percentiles in milliseconds over the last 30 minutes. Latency measures time to first token. Only visible when authenticated with an API key or cookie; returns null for unauthenticated requests.
+     * Uptime percentage over the last 1 day, calculated as successful requests / (successful + error requests) * 100. Rate-limited requests are excluded. Returns null if insufficient data.
      */
-    latencyLast30m: PercentileStats | null;
-    throughputLast30m: PercentileStats | null;
+    uptimeLast1d: number;
+    uptimeLast30m: number;
+    /**
+     * Uptime percentage over the last 5 minutes, calculated as successful requests / (successful + error requests) * 100. Rate-limited requests are excluded. Returns null if insufficient data.
+     */
+    uptimeLast5m: number;
 };
 /** @internal */
 export declare const Pricing$inboundSchema: z.ZodType<Pricing, unknown>;

package/esm/models/publicendpoint.js

@@ -23,30 +23,30 @@ export const PublicEndpointQuantization = {
 };
 /** @internal */
 export const Pricing$inboundSchema = z.object({
-    prompt: z.string(),
+    audio: z.string().optional(),
+    audio_output: z.string().optional(),
     completion: z.string(),
-    request: z.string().optional(),
+    discount: z.number().optional(),
     image: z.string().optional(),
-    image_token: z.string().optional(),
     image_output: z.string().optional(),
-    audio: z.string().optional(),
-    audio_output: z.string().optional(),
+    image_token: z.string().optional(),
     input_audio_cache: z.string().optional(),
-    web_search: z.string().optional(),
-    internal_reasoning: z.string().optional(),
     input_cache_read: z.string().optional(),
     input_cache_write: z.string().optional(),
-    discount: z.number().optional(),
+    internal_reasoning: z.string().optional(),
+    prompt: z.string(),
+    request: z.string().optional(),
+    web_search: z.string().optional(),
 }).transform((v) => {
     return remap$(v, {
-        "image_token": "imageToken",
-        "image_output": "imageOutput",
         "audio_output": "audioOutput",
+        "image_output": "imageOutput",
+        "image_token": "imageToken",
         "input_audio_cache": "inputAudioCache",
-        "web_search": "webSearch",
-        "internal_reasoning": "internalReasoning",
         "input_cache_read": "inputCacheRead",
         "input_cache_write": "inputCacheWrite",
+        "internal_reasoning": "internalReasoning",
+        "web_search": "webSearch",
     });
 });
 export function pricingFromJSON(jsonString) {
@@ -56,35 +56,39 @@ export function pricingFromJSON(jsonString) {
 export const PublicEndpointQuantization$inboundSchema = openEnums.inboundSchema(PublicEndpointQuantization);
 /** @internal */
 export const PublicEndpoint$inboundSchema = z.object({
-    name: z.string(),
+    context_length: z.int(),
+    latency_last_30m: z.nullable(PercentileStats$inboundSchema),
+    max_completion_tokens: z.int(),
+    max_prompt_tokens: z.int(),
     model_id: z.string(),
     model_name: z.string(),
-    context_length: z.number(),
+    name: z.string(),
     pricing: z.lazy(() => Pricing$inboundSchema),
     provider_name: ProviderName$inboundSchema,
-    tag: z.string(),
     quantization: z.nullable(PublicEndpointQuantization$inboundSchema),
-    max_completion_tokens: z.nullable(z.number()),
-    max_prompt_tokens: z.nullable(z.number()),
-    supported_parameters: z.array(Parameter$inboundSchema),
     status: EndpointStatus$inboundSchema.optional(),
-    uptime_last_30m: z.nullable(z.number()),
+    supported_parameters: z.array(Parameter$inboundSchema),
     supports_implicit_caching: z.boolean(),
-    latency_last_30m: z.nullable(PercentileStats$inboundSchema),
+    tag: z.string(),
     throughput_last_30m: z.nullable(PercentileStats$inboundSchema),
+    uptime_last_1d: z.number(),
+    uptime_last_30m: z.number(),
+    uptime_last_5m: z.number(),
 }).transform((v) => {
     return remap$(v, {
-        "model_id": "modelId",
-        "model_name": "modelName",
         "context_length": "contextLength",
-        "provider_name": "providerName",
+        "latency_last_30m": "latencyLast30m",
         "max_completion_tokens": "maxCompletionTokens",
         "max_prompt_tokens": "maxPromptTokens",
+        "model_id": "modelId",
+        "model_name": "modelName",
+        "provider_name": "providerName",
         "supported_parameters": "supportedParameters",
-        "uptime_last_30m": "uptimeLast30m",
         "supports_implicit_caching": "supportsImplicitCaching",
-        "latency_last_30m": "latencyLast30m",
         "throughput_last_30m": "throughputLast30m",
+        "uptime_last_1d": "uptimeLast1d",
+        "uptime_last_30m": "uptimeLast30m",
+        "uptime_last_5m": "uptimeLast5m",
     });
 });
 export function publicEndpointFromJSON(jsonString) {