@openrouter/sdk 0.3.12 → 0.3.14

package/esm/models/openresponsesrequest.js

@@ -17,10 +17,13 @@ import { OpenResponsesWebSearchPreview20250311Tool$outboundSchema, } from "./ope
 import { OpenResponsesWebSearchPreviewTool$outboundSchema, } from "./openresponseswebsearchpreviewtool.js";
 import { OpenResponsesWebSearchTool$outboundSchema, } from "./openresponseswebsearchtool.js";
 import { PDFParserOptions$outboundSchema, } from "./pdfparseroptions.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";
+import { ResponsesOutputModality$outboundSchema, } from "./responsesoutputmodality.js";
 import { WebSearchEngine$outboundSchema, } from "./websearchengine.js";
 export const ServiceTier = {
     Auto: "auto",
@@ -52,6 +55,11 @@ export function openResponsesRequestToolUnionToJSON(openResponsesRequestToolUnio
     return JSON.stringify(OpenResponsesRequestToolUnion$outboundSchema.parse(openResponsesRequestToolUnion));
 }
 /** @internal */
+export const OpenResponsesRequestImageConfig$outboundSchema = z.union([z.string(), z.number()]);
+export function openResponsesRequestImageConfigToJSON(openResponsesRequestImageConfig) {
+    return JSON.stringify(OpenResponsesRequestImageConfig$outboundSchema.parse(openResponsesRequestImageConfig));
+}
+/** @internal */
 export const ServiceTier$outboundSchema = z.enum(ServiceTier);
 /** @internal */
 export const Truncation$outboundSchema = openEnums.outboundSchema(Truncation);
@@ -110,10 +118,10 @@ export const OpenResponsesRequestProvider$outboundSchema = z.object({
     ])).optional(),
     maxPrice: z.lazy(() => OpenResponsesRequestMaxPrice$outboundSchema)
         .optional(),
-    preferredMinThroughput: z.nullable(z.number()).optional(),
-    preferredMaxLatency: z.nullable(z.number()).optional(),
-    minThroughput: z.nullable(z.number()).optional(),
-    maxLatency: z.nullable(z.number()).optional(),
+    preferredMinThroughput: z.nullable(PreferredMinThroughput$outboundSchema)
+        .optional(),
+    preferredMaxLatency: z.nullable(PreferredMaxLatency$outboundSchema)
+        .optional(),
 }).transform((v) => {
     return remap$(v, {
         allowFallbacks: "allow_fallbacks",
@@ -123,8 +131,6 @@ export const OpenResponsesRequestProvider$outboundSchema = z.object({
         maxPrice: "max_price",
         preferredMinThroughput: "preferred_min_throughput",
         preferredMaxLatency: "preferred_max_latency",
-        minThroughput: "min_throughput",
-        maxLatency: "max_latency",
     });
 });
 export function openResponsesRequestProviderToJSON(openResponsesRequestProvider) {
@@ -171,7 +177,21 @@ export function openResponsesRequestPluginModerationToJSON(openResponsesRequestP
     return JSON.stringify(OpenResponsesRequestPluginModeration$outboundSchema.parse(openResponsesRequestPluginModeration));
 }
 /** @internal */
+export const OpenResponsesRequestPluginAutoRouter$outboundSchema = z.object({
+    id: z.literal("auto-router"),
+    enabled: z.boolean().optional(),
+    allowedModels: z.array(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        allowedModels: "allowed_models",
+    });
+});
+export function openResponsesRequestPluginAutoRouterToJSON(openResponsesRequestPluginAutoRouter) {
+    return JSON.stringify(OpenResponsesRequestPluginAutoRouter$outboundSchema.parse(openResponsesRequestPluginAutoRouter));
+}
+/** @internal */
 export const OpenResponsesRequestPluginUnion$outboundSchema = z.union([
+    z.lazy(() => OpenResponsesRequestPluginAutoRouter$outboundSchema),
     z.lazy(() => OpenResponsesRequestPluginModeration$outboundSchema),
     z.lazy(() => OpenResponsesRequestPluginWeb$outboundSchema),
     z.lazy(() => OpenResponsesRequestPluginFileParser$outboundSchema),
@@ -201,7 +221,14 @@ export const OpenResponsesRequest$outboundSchema = z.object({
     maxOutputTokens: z.nullable(z.number()).optional(),
     temperature: z.nullable(z.number()).optional(),
     topP: z.nullable(z.number()).optional(),
+    topLogprobs: z.nullable(z.int()).optional(),
+    maxToolCalls: z.nullable(z.int()).optional(),
+    presencePenalty: z.nullable(z.number()).optional(),
+    frequencyPenalty: z.nullable(z.number()).optional(),
     topK: z.number().optional(),
+    imageConfig: z.record(z.string(), z.union([z.string(), z.number()]))
+        .optional(),
+    modalities: z.array(ResponsesOutputModality$outboundSchema).optional(),
     promptCacheKey: z.nullable(z.string()).optional(),
     previousResponseId: z.nullable(z.string()).optional(),
     prompt: z.nullable(OpenAIResponsesPrompt$outboundSchema).optional(),
@@ -215,6 +242,7 @@ export const OpenResponsesRequest$outboundSchema = z.object({
     stream: z.boolean().default(false),
     provider: z.nullable(z.lazy(() => OpenResponsesRequestProvider$outboundSchema)).optional(),
     plugins: z.array(z.union([
+        z.lazy(() => OpenResponsesRequestPluginAutoRouter$outboundSchema),
         z.lazy(() => OpenResponsesRequestPluginModeration$outboundSchema),
         z.lazy(() => OpenResponsesRequestPluginWeb$outboundSchema),
         z.lazy(() => OpenResponsesRequestPluginFileParser$outboundSchema),
@@ -228,7 +256,12 @@ export const OpenResponsesRequest$outboundSchema = z.object({
         parallelToolCalls: "parallel_tool_calls",
         maxOutputTokens: "max_output_tokens",
         topP: "top_p",
+        topLogprobs: "top_logprobs",
+        maxToolCalls: "max_tool_calls",
+        presencePenalty: "presence_penalty",
+        frequencyPenalty: "frequency_penalty",
         topK: "top_k",
+        imageConfig: "image_config",
         promptCacheKey: "prompt_cache_key",
         previousResponseId: "previous_response_id",
         safetyIdentifier: "safety_identifier",

package/esm/models/operations/getgeneration.d.ts

@@ -148,6 +148,10 @@ export type GetGenerationData = {
      * Type of API used for the generation
      */
     apiType: ApiType | null;
+    /**
+     * Router used for the request (e.g., openrouter/auto)
+     */
+    router: string | null;
 };
 /**
  * Generation response

package/esm/models/operations/getgeneration.js

@@ -57,6 +57,7 @@ export const GetGenerationData$inboundSchema = z.object({
     native_finish_reason: z.nullable(z.string()),
     external_user: z.nullable(z.string()),
     api_type: z.nullable(ApiType$inboundSchema),
+    router: z.nullable(z.string()),
 }).transform((v) => {
     return remap$(v, {
         "upstream_id": "upstreamId",

package/esm/models/percentilelatencycutoffs.d.ts

@@ -0,0 +1,33 @@
+import * as z from "zod/v4";
+/**
+ * Percentile-based latency cutoffs. All specified cutoffs must be met for an endpoint to be preferred.
+ */
+export type PercentileLatencyCutoffs = {
+    /**
+     * Maximum p50 latency (seconds)
+     */
+    p50?: number | null | undefined;
+    /**
+     * Maximum p75 latency (seconds)
+     */
+    p75?: number | null | undefined;
+    /**
+     * Maximum p90 latency (seconds)
+     */
+    p90?: number | null | undefined;
+    /**
+     * Maximum p99 latency (seconds)
+     */
+    p99?: number | null | undefined;
+};
+/** @internal */
+export type PercentileLatencyCutoffs$Outbound = {
+    p50?: number | null | undefined;
+    p75?: number | null | undefined;
+    p90?: number | null | undefined;
+    p99?: number | null | undefined;
+};
+/** @internal */
+export declare const PercentileLatencyCutoffs$outboundSchema: z.ZodType<PercentileLatencyCutoffs$Outbound, PercentileLatencyCutoffs>;
+export declare function percentileLatencyCutoffsToJSON(percentileLatencyCutoffs: PercentileLatencyCutoffs): string;
+//# sourceMappingURL=percentilelatencycutoffs.d.ts.map

package/esm/models/percentilelatencycutoffs.js

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 92e053096488
+ */
+import * as z from "zod/v4";
+/** @internal */
+export const PercentileLatencyCutoffs$outboundSchema = z.object({
+    p50: z.nullable(z.number()).optional(),
+    p75: z.nullable(z.number()).optional(),
+    p90: z.nullable(z.number()).optional(),
+    p99: z.nullable(z.number()).optional(),
+});
+export function percentileLatencyCutoffsToJSON(percentileLatencyCutoffs) {
+    return JSON.stringify(PercentileLatencyCutoffs$outboundSchema.parse(percentileLatencyCutoffs));
+}
+//# sourceMappingURL=percentilelatencycutoffs.js.map

package/esm/models/percentilestats.d.ts

@@ -0,0 +1,28 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * 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.
+ */
+export type PercentileStats = {
+    /**
+     * Median (50th percentile)
+     */
+    p50: number;
+    /**
+     * 75th percentile
+     */
+    p75: number;
+    /**
+     * 90th percentile
+     */
+    p90: number;
+    /**
+     * 99th percentile
+     */
+    p99: number;
+};
+/** @internal */
+export declare const PercentileStats$inboundSchema: z.ZodType<PercentileStats, unknown>;
+export declare function percentileStatsFromJSON(jsonString: string): SafeParseResult<PercentileStats, SDKValidationError>;
+//# sourceMappingURL=percentilestats.d.ts.map

package/esm/models/percentilestats.js

@@ -0,0 +1,17 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 9a6b504d3964
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const PercentileStats$inboundSchema = z.object({
+    p50: z.number(),
+    p75: z.number(),
+    p90: z.number(),
+    p99: z.number(),
+});
+export function percentileStatsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => PercentileStats$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'PercentileStats' from JSON`);
+}
+//# sourceMappingURL=percentilestats.js.map

package/esm/models/percentilethroughputcutoffs.d.ts

@@ -0,0 +1,33 @@
+import * as z from "zod/v4";
+/**
+ * Percentile-based throughput cutoffs. All specified cutoffs must be met for an endpoint to be preferred.
+ */
+export type PercentileThroughputCutoffs = {
+    /**
+     * Minimum p50 throughput (tokens/sec)
+     */
+    p50?: number | null | undefined;
+    /**
+     * Minimum p75 throughput (tokens/sec)
+     */
+    p75?: number | null | undefined;
+    /**
+     * Minimum p90 throughput (tokens/sec)
+     */
+    p90?: number | null | undefined;
+    /**
+     * Minimum p99 throughput (tokens/sec)
+     */
+    p99?: number | null | undefined;
+};
+/** @internal */
+export type PercentileThroughputCutoffs$Outbound = {
+    p50?: number | null | undefined;
+    p75?: number | null | undefined;
+    p90?: number | null | undefined;
+    p99?: number | null | undefined;
+};
+/** @internal */
+export declare const PercentileThroughputCutoffs$outboundSchema: z.ZodType<PercentileThroughputCutoffs$Outbound, PercentileThroughputCutoffs>;
+export declare function percentileThroughputCutoffsToJSON(percentileThroughputCutoffs: PercentileThroughputCutoffs): string;
+//# sourceMappingURL=percentilethroughputcutoffs.d.ts.map

package/esm/models/percentilethroughputcutoffs.js

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 847aba8ff633
+ */
+import * as z from "zod/v4";
+/** @internal */
+export const PercentileThroughputCutoffs$outboundSchema = z.object({
+    p50: z.nullable(z.number()).optional(),
+    p75: z.nullable(z.number()).optional(),
+    p90: z.nullable(z.number()).optional(),
+    p99: z.nullable(z.number()).optional(),
+});
+export function percentileThroughputCutoffsToJSON(percentileThroughputCutoffs) {
+    return JSON.stringify(PercentileThroughputCutoffs$outboundSchema.parse(percentileThroughputCutoffs));
+}
+//# sourceMappingURL=percentilethroughputcutoffs.js.map

package/esm/models/preferredmaxlatency.d.ts

@@ -0,0 +1,12 @@
+import * as z from "zod/v4";
+import { PercentileLatencyCutoffs, PercentileLatencyCutoffs$Outbound } from "./percentilelatencycutoffs.js";
+/**
+ * Preferred maximum latency (in seconds). Can be a number (applies to p50) or an object with percentile-specific cutoffs. Endpoints above the threshold(s) may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
+ */
+export type PreferredMaxLatency = number | PercentileLatencyCutoffs | any;
+/** @internal */
+export type PreferredMaxLatency$Outbound = number | PercentileLatencyCutoffs$Outbound | any;
+/** @internal */
+export declare const PreferredMaxLatency$outboundSchema: z.ZodType<PreferredMaxLatency$Outbound, PreferredMaxLatency>;
+export declare function preferredMaxLatencyToJSON(preferredMaxLatency: PreferredMaxLatency): string;
+//# sourceMappingURL=preferredmaxlatency.d.ts.map

package/esm/models/preferredmaxlatency.js

@@ -0,0 +1,12 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e03f33269427
+ */
+import * as z from "zod/v4";
+import { PercentileLatencyCutoffs$outboundSchema, } from "./percentilelatencycutoffs.js";
+/** @internal */
+export const PreferredMaxLatency$outboundSchema = z.union([z.number(), PercentileLatencyCutoffs$outboundSchema, z.any()]);
+export function preferredMaxLatencyToJSON(preferredMaxLatency) {
+    return JSON.stringify(PreferredMaxLatency$outboundSchema.parse(preferredMaxLatency));
+}
+//# sourceMappingURL=preferredmaxlatency.js.map

package/esm/models/preferredminthroughput.d.ts

@@ -0,0 +1,12 @@
+import * as z from "zod/v4";
+import { PercentileThroughputCutoffs, PercentileThroughputCutoffs$Outbound } from "./percentilethroughputcutoffs.js";
+/**
+ * Preferred minimum throughput (in tokens per second). Can be a number (applies to p50) or an object with percentile-specific cutoffs. Endpoints below the threshold(s) may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
+ */
+export type PreferredMinThroughput = number | PercentileThroughputCutoffs | any;
+/** @internal */
+export type PreferredMinThroughput$Outbound = number | PercentileThroughputCutoffs$Outbound | any;
+/** @internal */
+export declare const PreferredMinThroughput$outboundSchema: z.ZodType<PreferredMinThroughput$Outbound, PreferredMinThroughput>;
+export declare function preferredMinThroughputToJSON(preferredMinThroughput: PreferredMinThroughput): string;
+//# sourceMappingURL=preferredminthroughput.d.ts.map

package/esm/models/preferredminthroughput.js

@@ -0,0 +1,12 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 5ff9056f1474
+ */
+import * as z from "zod/v4";
+import { PercentileThroughputCutoffs$outboundSchema, } from "./percentilethroughputcutoffs.js";
+/** @internal */
+export const PreferredMinThroughput$outboundSchema = z.union([z.number(), PercentileThroughputCutoffs$outboundSchema, z.any()]);
+export function preferredMinThroughputToJSON(preferredMinThroughput) {
+    return JSON.stringify(PreferredMinThroughput$outboundSchema.parse(preferredMinThroughput));
+}
+//# sourceMappingURL=preferredminthroughput.js.map

package/esm/models/providername.d.ts

@@ -27,12 +27,12 @@ export declare const ProviderName: {
     readonly Fireworks: "Fireworks";
     readonly Friendli: "Friendli";
     readonly GMICloud: "GMICloud";
-    readonly GoPomelo: "GoPomelo";
     readonly Google: "Google";
     readonly GoogleAIStudio: "Google AI Studio";
     readonly Groq: "Groq";
     readonly Hyperbolic: "Hyperbolic";
     readonly Inception: "Inception";
+    readonly Inceptron: "Inceptron";
     readonly InferenceNet: "InferenceNet";
     readonly Infermatic: "Infermatic";
     readonly Inflection: "Inflection";
@@ -57,13 +57,14 @@ export declare const ProviderName: {
     readonly Phala: "Phala";
     readonly Relace: "Relace";
     readonly SambaNova: "SambaNova";
+    readonly Seed: "Seed";
     readonly SiliconFlow: "SiliconFlow";
     readonly Sourceful: "Sourceful";
     readonly Stealth: "Stealth";
     readonly StreamLake: "StreamLake";
     readonly Switchpoint: "Switchpoint";
-    readonly Targon: "Targon";
     readonly Together: "Together";
+    readonly Upstage: "Upstage";
     readonly Venice: "Venice";
     readonly WandB: "WandB";
     readonly Xiaomi: "Xiaomi";

package/esm/models/providername.js

@@ -30,12 +30,12 @@ export const ProviderName = {
     Fireworks: "Fireworks",
     Friendli: "Friendli",
     GMICloud: "GMICloud",
-    GoPomelo: "GoPomelo",
     Google: "Google",
     GoogleAIStudio: "Google AI Studio",
     Groq: "Groq",
     Hyperbolic: "Hyperbolic",
     Inception: "Inception",
+    Inceptron: "Inceptron",
     InferenceNet: "InferenceNet",
     Infermatic: "Infermatic",
     Inflection: "Inflection",
@@ -60,13 +60,14 @@ export const ProviderName = {
     Phala: "Phala",
     Relace: "Relace",
     SambaNova: "SambaNova",
+    Seed: "Seed",
     SiliconFlow: "SiliconFlow",
     Sourceful: "Sourceful",
     Stealth: "Stealth",
     StreamLake: "StreamLake",
     Switchpoint: "Switchpoint",
-    Targon: "Targon",
     Together: "Together",
+    Upstage: "Upstage",
     Venice: "Venice",
     WandB: "WandB",
     Xiaomi: "Xiaomi",

package/esm/models/providerpreferences.d.ts

@@ -1,6 +1,8 @@
 import * as z from "zod/v4";
 import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { DataCollection } from "./datacollection.js";
+import { PreferredMaxLatency, PreferredMaxLatency$Outbound } from "./preferredmaxlatency.js";
+import { PreferredMinThroughput, PreferredMinThroughput$Outbound } from "./preferredminthroughput.js";
 import { ProviderName } from "./providername.js";
 import { ProviderSort } from "./providersort.js";
 import { Quantization } from "./quantization.js";
@@ -119,25 +121,13 @@ export type ProviderPreferences = {
      */
     maxPrice?: ProviderPreferencesMaxPrice | undefined;
     /**
-     * Preferred minimum throughput (in tokens per second). Endpoints below this threshold may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
+     * Preferred minimum throughput (in tokens per second). Can be a number (applies to p50) or an object with percentile-specific cutoffs. Endpoints below the threshold(s) may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
      */
-    preferredMinThroughput?: number | null | undefined;
+    preferredMinThroughput?: PreferredMinThroughput | null | undefined;
     /**
-     * Preferred maximum latency (in seconds). Endpoints above this threshold may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
+     * Preferred maximum latency (in seconds). Can be a number (applies to p50) or an object with percentile-specific cutoffs. Endpoints above the threshold(s) may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
      */
-    preferredMaxLatency?: number | null | undefined;
-    /**
-     * **DEPRECATED** Use preferred_min_throughput instead. Backwards-compatible alias for preferred_min_throughput.
-     *
-     * @deprecated field: Use preferred_min_throughput instead..
-     */
-    minThroughput?: number | null | undefined;
-    /**
-     * **DEPRECATED** Use preferred_max_latency instead. Backwards-compatible alias for preferred_max_latency.
-     *
-     * @deprecated field: Use preferred_max_latency instead..
-     */
-    maxLatency?: number | null | undefined;
+    preferredMaxLatency?: PreferredMaxLatency | null | undefined;
 };
 /** @internal */
 export type ProviderPreferencesOrder$Outbound = string | string;
@@ -204,10 +194,8 @@ export type ProviderPreferences$Outbound = {
     quantizations?: Array<string> | null | undefined;
     sort?: string | ProviderPreferencesProviderSortConfig$Outbound | string | string | null | undefined;
     max_price?: ProviderPreferencesMaxPrice$Outbound | undefined;
-    preferred_min_throughput?: number | null | undefined;
-    preferred_max_latency?: number | null | undefined;
-    min_throughput?: number | null | undefined;
-    max_latency?: number | null | undefined;
+    preferred_min_throughput?: PreferredMinThroughput$Outbound | null | undefined;
+    preferred_max_latency?: PreferredMaxLatency$Outbound | null | undefined;
 };
 /** @internal */
 export declare const ProviderPreferences$outboundSchema: z.ZodType<ProviderPreferences$Outbound, ProviderPreferences>;

package/esm/models/providerpreferences.js

@@ -6,6 +6,8 @@ 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 { Quantization$outboundSchema } from "./quantization.js";
@@ -113,10 +115,10 @@ export const ProviderPreferences$outboundSchema = z.object({
         SortEnum$outboundSchema,
     ])).optional(),
     maxPrice: z.lazy(() => ProviderPreferencesMaxPrice$outboundSchema).optional(),
-    preferredMinThroughput: z.nullable(z.number()).optional(),
-    preferredMaxLatency: z.nullable(z.number()).optional(),
-    minThroughput: z.nullable(z.number()).optional(),
-    maxLatency: z.nullable(z.number()).optional(),
+    preferredMinThroughput: z.nullable(PreferredMinThroughput$outboundSchema)
+        .optional(),
+    preferredMaxLatency: z.nullable(PreferredMaxLatency$outboundSchema)
+        .optional(),
 }).transform((v) => {
     return remap$(v, {
         allowFallbacks: "allow_fallbacks",
@@ -126,8 +128,6 @@ export const ProviderPreferences$outboundSchema = z.object({
         maxPrice: "max_price",
         preferredMinThroughput: "preferred_min_throughput",
         preferredMaxLatency: "preferred_max_latency",
-        minThroughput: "min_throughput",
-        maxLatency: "max_latency",
     });
 });
 export function providerPreferencesToJSON(providerPreferences) {

package/esm/models/publicendpoint.d.ts

@@ -4,6 +4,7 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import { EndpointStatus } from "./endpointstatus.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { Parameter } from "./parameter.js";
+import { PercentileStats } from "./percentilestats.js";
 import { ProviderName } from "./providername.js";
 export type Pricing = {
     /**
@@ -85,6 +86,11 @@ export type PublicEndpoint = {
     status?: EndpointStatus | undefined;
     uptimeLast30m: number | null;
     supportsImplicitCaching: boolean;
+    /**
+     * 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;
+    throughputLast30m: PercentileStats | null;
 };
 /** @internal */
 export declare const Pricing$inboundSchema: z.ZodType<Pricing, unknown>;

package/esm/models/publicendpoint.js

@@ -8,6 +8,7 @@ import { safeParse } from "../lib/schemas.js";
 import * as openEnums from "../types/enums.js";
 import { EndpointStatus$inboundSchema, } from "./endpointstatus.js";
 import { Parameter$inboundSchema } from "./parameter.js";
+import { PercentileStats$inboundSchema, } from "./percentilestats.js";
 import { ProviderName$inboundSchema } from "./providername.js";
 export const PublicEndpointQuantization = {
     Int4: "int4",
@@ -66,6 +67,8 @@ export const PublicEndpoint$inboundSchema = z.object({
     status: EndpointStatus$inboundSchema.optional(),
     uptime_last_30m: z.nullable(z.number()),
     supports_implicit_caching: z.boolean(),
+    latency_last_30m: z.nullable(PercentileStats$inboundSchema),
+    throughput_last_30m: z.nullable(PercentileStats$inboundSchema),
 }).transform((v) => {
     return remap$(v, {
         "model_name": "modelName",
@@ -76,6 +79,8 @@ export const PublicEndpoint$inboundSchema = z.object({
         "supported_parameters": "supportedParameters",
         "uptime_last_30m": "uptimeLast30m",
         "supports_implicit_caching": "supportsImplicitCaching",
+        "latency_last_30m": "latencyLast30m",
+        "throughput_last_30m": "throughputLast30m",
     });
 });
 export function publicEndpointFromJSON(jsonString) {

package/esm/models/responseinputimage.d.ts

@@ -1,7 +1,11 @@
 import * as z from "zod/v4";
-import { OpenEnum } from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ResponseInputImageType: {
+    readonly InputImage: "input_image";
+};
+export type ResponseInputImageType = ClosedEnum<typeof ResponseInputImageType>;
 export declare const ResponseInputImageDetail: {
     readonly Auto: "auto";
     readonly High: "high";
@@ -12,11 +16,15 @@ export type ResponseInputImageDetail = OpenEnum<typeof ResponseInputImageDetail>
  * Image input content item
  */
 export type ResponseInputImage = {
-    type: "input_image";
+    type: ResponseInputImageType;
     detail: ResponseInputImageDetail;
     imageUrl?: string | null | undefined;
 };
 /** @internal */
+export declare const ResponseInputImageType$inboundSchema: z.ZodEnum<typeof ResponseInputImageType>;
+/** @internal */
+export declare const ResponseInputImageType$outboundSchema: z.ZodEnum<typeof ResponseInputImageType>;
+/** @internal */
 export declare const ResponseInputImageDetail$inboundSchema: z.ZodType<ResponseInputImageDetail, unknown>;
 /** @internal */
 export declare const ResponseInputImageDetail$outboundSchema: z.ZodType<string, ResponseInputImageDetail>;
@@ -24,7 +32,7 @@ export declare const ResponseInputImageDetail$outboundSchema: z.ZodType<string,
 export declare const ResponseInputImage$inboundSchema: z.ZodType<ResponseInputImage, unknown>;
 /** @internal */
 export type ResponseInputImage$Outbound = {
-    type: "input_image";
+    type: string;
     detail: string;
     image_url?: string | null | undefined;
 };

package/esm/models/responseinputimage.js

@@ -6,18 +6,25 @@ 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";
+export const ResponseInputImageType = {
+    InputImage: "input_image",
+};
 export const ResponseInputImageDetail = {
     Auto: "auto",
     High: "high",
     Low: "low",
 };
 /** @internal */
+export const ResponseInputImageType$inboundSchema = z.enum(ResponseInputImageType);
+/** @internal */
+export const ResponseInputImageType$outboundSchema = ResponseInputImageType$inboundSchema;
+/** @internal */
 export const ResponseInputImageDetail$inboundSchema = openEnums.inboundSchema(ResponseInputImageDetail);
 /** @internal */
 export const ResponseInputImageDetail$outboundSchema = openEnums.outboundSchema(ResponseInputImageDetail);
 /** @internal */
 export const ResponseInputImage$inboundSchema = z.object({
-    type: z.literal("input_image"),
+    type: ResponseInputImageType$inboundSchema,
     detail: ResponseInputImageDetail$inboundSchema,
     image_url: z.nullable(z.string()).optional(),
 }).transform((v) => {
@@ -27,7 +34,7 @@ export const ResponseInputImage$inboundSchema = z.object({
 });
 /** @internal */
 export const ResponseInputImage$outboundSchema = z.object({
-    type: z.literal("input_image"),
+    type: ResponseInputImageType$outboundSchema,
     detail: ResponseInputImageDetail$outboundSchema,
     imageUrl: z.nullable(z.string()).optional(),
 }).transform((v) => {

package/esm/models/responseinputvideo.d.ts

@@ -0,0 +1,20 @@
+import * as z from "zod/v4";
+/**
+ * Video input content item
+ */
+export type ResponseInputVideo = {
+    type: "input_video";
+    /**
+     * A base64 data URL or remote URL that resolves to a video file
+     */
+    videoUrl: string;
+};
+/** @internal */
+export type ResponseInputVideo$Outbound = {
+    type: "input_video";
+    video_url: string;
+};
+/** @internal */
+export declare const ResponseInputVideo$outboundSchema: z.ZodType<ResponseInputVideo$Outbound, ResponseInputVideo>;
+export declare function responseInputVideoToJSON(responseInputVideo: ResponseInputVideo): string;
+//# sourceMappingURL=responseinputvideo.d.ts.map

package/esm/models/responseinputvideo.js

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 79bef840e448
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+/** @internal */
+export const ResponseInputVideo$outboundSchema = z.object({
+    type: z.literal("input_video"),
+    videoUrl: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        videoUrl: "video_url",
+    });
+});
+export function responseInputVideoToJSON(responseInputVideo) {
+    return JSON.stringify(ResponseInputVideo$outboundSchema.parse(responseInputVideo));
+}
+//# sourceMappingURL=responseinputvideo.js.map