@openrouter/sdk 0.2.9 → 0.3.1

package/esm/models/openairesponsesreasoningeffort.d.ts

@@ -1,6 +1,7 @@
 import * as z from "zod/v4";
 import { OpenEnum } from "../types/enums.js";
 export declare const OpenAIResponsesReasoningEffort: {
+    readonly Xhigh: "xhigh";
     readonly High: "high";
     readonly Medium: "medium";
     readonly Low: "low";

package/esm/models/openairesponsesreasoningeffort.js

@@ -3,6 +3,7 @@
  */
 import * as openEnums from "../types/enums.js";
 export const OpenAIResponsesReasoningEffort = {
+    Xhigh: "xhigh",
     High: "high",
     Medium: "medium",
     Low: "low",

package/esm/models/openresponsesrequest.d.ts

@@ -11,9 +11,12 @@ import { OpenResponsesWebSearch20250826Tool, OpenResponsesWebSearch20250826Tool$
 import { OpenResponsesWebSearchPreview20250311Tool, OpenResponsesWebSearchPreview20250311Tool$Outbound } from "./openresponseswebsearchpreview20250311tool.js";
 import { OpenResponsesWebSearchPreviewTool, OpenResponsesWebSearchPreviewTool$Outbound } from "./openresponseswebsearchpreviewtool.js";
 import { OpenResponsesWebSearchTool, OpenResponsesWebSearchTool$Outbound } from "./openresponseswebsearchtool.js";
+import { PDFParserOptions, PDFParserOptions$Outbound } from "./pdfparseroptions.js";
 import { ProviderName } from "./providername.js";
 import { ProviderSort } from "./providersort.js";
+import { ProviderSortConfig, ProviderSortConfig$Outbound } from "./providersortconfig.js";
 import { Quantization } from "./quantization.js";
+import { WebSearchEngine } from "./websearchengine.js";
 /**
  * Function tool definition
  */
@@ -36,38 +39,42 @@ export declare const Truncation: {
     readonly Disabled: "disabled";
 };
 export type Truncation = OpenEnum<typeof Truncation>;
-export type Order = ProviderName | string;
-export type Only = ProviderName | string;
-export type Ignore = ProviderName | string;
+export type OpenResponsesRequestOrder = ProviderName | string;
+export type OpenResponsesRequestOnly = ProviderName | string;
+export type OpenResponsesRequestIgnore = ProviderName | string;
+/**
+ * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
+ */
+export type OpenResponsesRequestSort = ProviderSort | ProviderSortConfig | any;
 /**
  * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
  */
-export type MaxPrice = {
+export type OpenResponsesRequestMaxPrice = {
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    prompt?: any | undefined;
+    prompt?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    completion?: any | undefined;
+    completion?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    image?: any | undefined;
+    image?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    audio?: any | undefined;
+    audio?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    request?: any | undefined;
+    request?: string | undefined;
 };
 /**
  * When multiple model providers are available, optionally indicate your routing preference.
  */
-export type Provider = {
+export type OpenResponsesRequestProvider = {
     /**
      * Whether to allow backup providers to serve requests
      *
@@ -116,44 +123,67 @@ export type Provider = {
     /**
      * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
      */
-    sort?: ProviderSort | null | undefined;
+    sort?: ProviderSort | ProviderSortConfig | any | null | undefined;
     /**
      * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
      */
-    maxPrice?: MaxPrice | undefined;
+    maxPrice?: OpenResponsesRequestMaxPrice | 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.
+     */
+    preferredMinThroughput?: number | 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.
+     */
+    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;
 };
-export type PluginResponseHealing = {
+export type OpenResponsesRequestPluginResponseHealing = {
     id: "response-healing";
+    /**
+     * Set to false to disable the response-healing plugin for this request. Defaults to true.
+     */
+    enabled?: boolean | undefined;
 };
-export declare const PdfEngine: {
-    readonly MistralOcr: "mistral-ocr";
-    readonly PdfText: "pdf-text";
-    readonly Native: "native";
-};
-export type PdfEngine = OpenEnum<typeof PdfEngine>;
-export type Pdf = {
-    engine?: PdfEngine | undefined;
-};
-export type PluginFileParser = {
+export type OpenResponsesRequestPluginFileParser = {
     id: "file-parser";
-    maxFiles?: number | undefined;
-    pdf?: Pdf | undefined;
-};
-export declare const Engine: {
-    readonly Native: "native";
-    readonly Exa: "exa";
+    /**
+     * Set to false to disable the file-parser plugin for this request. Defaults to true.
+     */
+    enabled?: boolean | undefined;
+    /**
+     * Options for PDF parsing.
+     */
+    pdf?: PDFParserOptions | undefined;
 };
-export type Engine = OpenEnum<typeof Engine>;
-export type PluginWeb = {
+export type OpenResponsesRequestPluginWeb = {
     id: "web";
+    /**
+     * Set to false to disable the web-search plugin for this request. Defaults to true.
+     */
+    enabled?: boolean | undefined;
     maxResults?: number | undefined;
     searchPrompt?: string | undefined;
-    engine?: Engine | undefined;
+    /**
+     * The search engine to use for web search.
+     */
+    engine?: WebSearchEngine | undefined;
 };
-export type PluginModeration = {
+export type OpenResponsesRequestPluginModeration = {
     id: "moderation";
 };
-export type Plugin = PluginModeration | PluginWeb | PluginFileParser | PluginResponseHealing;
+export type OpenResponsesRequestPluginUnion = OpenResponsesRequestPluginModeration | OpenResponsesRequestPluginWeb | OpenResponsesRequestPluginFileParser | OpenResponsesRequestPluginResponseHealing;
 /**
  * Request schema for Responses endpoint
  */
@@ -199,15 +229,19 @@ export type OpenResponsesRequest = {
     /**
      * When multiple model providers are available, optionally indicate your routing preference.
      */
-    provider?: Provider | null | undefined;
+    provider?: OpenResponsesRequestProvider | null | undefined;
     /**
      * Plugins you want to enable for this request, including their settings.
      */
-    plugins?: Array<PluginModeration | PluginWeb | PluginFileParser | PluginResponseHealing> | undefined;
+    plugins?: Array<OpenResponsesRequestPluginModeration | OpenResponsesRequestPluginWeb | OpenResponsesRequestPluginFileParser | OpenResponsesRequestPluginResponseHealing> | undefined;
     /**
      * A unique identifier representing your end-user, which helps distinguish between different users of your app. This allows your app to identify specific users in case of abuse reports, preventing your entire app from being affected by the actions of individual users. Maximum of 128 characters.
      */
     user?: string | undefined;
+    /**
+     * A unique identifier for grouping related requests (e.g., a conversation or agent workflow) for observability. If provided in both the request body and the x-session-id header, the body value takes precedence. Maximum of 128 characters.
+     */
+    sessionId?: string | undefined;
 };
 /** @internal */
 export type OpenResponsesRequestToolFunction$Outbound = {
@@ -232,33 +266,38 @@ export declare const ServiceTier$outboundSchema: z.ZodEnum<typeof ServiceTier>;
 /** @internal */
 export declare const Truncation$outboundSchema: z.ZodType<string, Truncation>;
 /** @internal */
-export type Order$Outbound = string | string;
+export type OpenResponsesRequestOrder$Outbound = string | string;
 /** @internal */
-export declare const Order$outboundSchema: z.ZodType<Order$Outbound, Order>;
-export declare function orderToJSON(order: Order): string;
+export declare const OpenResponsesRequestOrder$outboundSchema: z.ZodType<OpenResponsesRequestOrder$Outbound, OpenResponsesRequestOrder>;
+export declare function openResponsesRequestOrderToJSON(openResponsesRequestOrder: OpenResponsesRequestOrder): string;
 /** @internal */
-export type Only$Outbound = string | string;
+export type OpenResponsesRequestOnly$Outbound = string | string;
 /** @internal */
-export declare const Only$outboundSchema: z.ZodType<Only$Outbound, Only>;
-export declare function onlyToJSON(only: Only): string;
+export declare const OpenResponsesRequestOnly$outboundSchema: z.ZodType<OpenResponsesRequestOnly$Outbound, OpenResponsesRequestOnly>;
+export declare function openResponsesRequestOnlyToJSON(openResponsesRequestOnly: OpenResponsesRequestOnly): string;
 /** @internal */
-export type Ignore$Outbound = string | string;
+export type OpenResponsesRequestIgnore$Outbound = string | string;
 /** @internal */
-export declare const Ignore$outboundSchema: z.ZodType<Ignore$Outbound, Ignore>;
-export declare function ignoreToJSON(ignore: Ignore): string;
+export declare const OpenResponsesRequestIgnore$outboundSchema: z.ZodType<OpenResponsesRequestIgnore$Outbound, OpenResponsesRequestIgnore>;
+export declare function openResponsesRequestIgnoreToJSON(openResponsesRequestIgnore: OpenResponsesRequestIgnore): string;
 /** @internal */
-export type MaxPrice$Outbound = {
-    prompt?: any | undefined;
-    completion?: any | undefined;
-    image?: any | undefined;
-    audio?: any | undefined;
-    request?: any | undefined;
+export type OpenResponsesRequestSort$Outbound = string | ProviderSortConfig$Outbound | any;
+/** @internal */
+export declare const OpenResponsesRequestSort$outboundSchema: z.ZodType<OpenResponsesRequestSort$Outbound, OpenResponsesRequestSort>;
+export declare function openResponsesRequestSortToJSON(openResponsesRequestSort: OpenResponsesRequestSort): string;
+/** @internal */
+export type OpenResponsesRequestMaxPrice$Outbound = {
+    prompt?: string | undefined;
+    completion?: string | undefined;
+    image?: string | undefined;
+    audio?: string | undefined;
+    request?: string | undefined;
 };
 /** @internal */
-export declare const MaxPrice$outboundSchema: z.ZodType<MaxPrice$Outbound, MaxPrice>;
-export declare function maxPriceToJSON(maxPrice: MaxPrice): string;
+export declare const OpenResponsesRequestMaxPrice$outboundSchema: z.ZodType<OpenResponsesRequestMaxPrice$Outbound, OpenResponsesRequestMaxPrice>;
+export declare function openResponsesRequestMaxPriceToJSON(openResponsesRequestMaxPrice: OpenResponsesRequestMaxPrice): string;
 /** @internal */
-export type Provider$Outbound = {
+export type OpenResponsesRequestProvider$Outbound = {
     allow_fallbacks?: boolean | null | undefined;
     require_parameters?: boolean | null | undefined;
     data_collection?: string | null | undefined;
@@ -268,61 +307,56 @@ export type Provider$Outbound = {
     only?: Array<string | string> | null | undefined;
     ignore?: Array<string | string> | null | undefined;
     quantizations?: Array<string> | null | undefined;
-    sort?: string | null | undefined;
-    max_price?: MaxPrice$Outbound | undefined;
+    sort?: string | ProviderSortConfig$Outbound | any | null | undefined;
+    max_price?: OpenResponsesRequestMaxPrice$Outbound | undefined;
+    preferred_min_throughput?: number | null | undefined;
+    preferred_max_latency?: number | null | undefined;
+    min_throughput?: number | null | undefined;
+    max_latency?: number | null | undefined;
 };
 /** @internal */
-export declare const Provider$outboundSchema: z.ZodType<Provider$Outbound, Provider>;
-export declare function providerToJSON(provider: Provider): string;
+export declare const OpenResponsesRequestProvider$outboundSchema: z.ZodType<OpenResponsesRequestProvider$Outbound, OpenResponsesRequestProvider>;
+export declare function openResponsesRequestProviderToJSON(openResponsesRequestProvider: OpenResponsesRequestProvider): string;
 /** @internal */
-export type PluginResponseHealing$Outbound = {
+export type OpenResponsesRequestPluginResponseHealing$Outbound = {
     id: "response-healing";
+    enabled?: boolean | undefined;
 };
 /** @internal */
-export declare const PluginResponseHealing$outboundSchema: z.ZodType<PluginResponseHealing$Outbound, PluginResponseHealing>;
-export declare function pluginResponseHealingToJSON(pluginResponseHealing: PluginResponseHealing): string;
-/** @internal */
-export declare const PdfEngine$outboundSchema: z.ZodType<string, PdfEngine>;
-/** @internal */
-export type Pdf$Outbound = {
-    engine?: string | undefined;
-};
-/** @internal */
-export declare const Pdf$outboundSchema: z.ZodType<Pdf$Outbound, Pdf>;
-export declare function pdfToJSON(pdf: Pdf): string;
+export declare const OpenResponsesRequestPluginResponseHealing$outboundSchema: z.ZodType<OpenResponsesRequestPluginResponseHealing$Outbound, OpenResponsesRequestPluginResponseHealing>;
+export declare function openResponsesRequestPluginResponseHealingToJSON(openResponsesRequestPluginResponseHealing: OpenResponsesRequestPluginResponseHealing): string;
 /** @internal */
-export type PluginFileParser$Outbound = {
+export type OpenResponsesRequestPluginFileParser$Outbound = {
     id: "file-parser";
-    max_files?: number | undefined;
-    pdf?: Pdf$Outbound | undefined;
+    enabled?: boolean | undefined;
+    pdf?: PDFParserOptions$Outbound | undefined;
 };
 /** @internal */
-export declare const PluginFileParser$outboundSchema: z.ZodType<PluginFileParser$Outbound, PluginFileParser>;
-export declare function pluginFileParserToJSON(pluginFileParser: PluginFileParser): string;
-/** @internal */
-export declare const Engine$outboundSchema: z.ZodType<string, Engine>;
+export declare const OpenResponsesRequestPluginFileParser$outboundSchema: z.ZodType<OpenResponsesRequestPluginFileParser$Outbound, OpenResponsesRequestPluginFileParser>;
+export declare function openResponsesRequestPluginFileParserToJSON(openResponsesRequestPluginFileParser: OpenResponsesRequestPluginFileParser): string;
 /** @internal */
-export type PluginWeb$Outbound = {
+export type OpenResponsesRequestPluginWeb$Outbound = {
     id: "web";
+    enabled?: boolean | undefined;
     max_results?: number | undefined;
     search_prompt?: string | undefined;
     engine?: string | undefined;
 };
 /** @internal */
-export declare const PluginWeb$outboundSchema: z.ZodType<PluginWeb$Outbound, PluginWeb>;
-export declare function pluginWebToJSON(pluginWeb: PluginWeb): string;
+export declare const OpenResponsesRequestPluginWeb$outboundSchema: z.ZodType<OpenResponsesRequestPluginWeb$Outbound, OpenResponsesRequestPluginWeb>;
+export declare function openResponsesRequestPluginWebToJSON(openResponsesRequestPluginWeb: OpenResponsesRequestPluginWeb): string;
 /** @internal */
-export type PluginModeration$Outbound = {
+export type OpenResponsesRequestPluginModeration$Outbound = {
     id: "moderation";
 };
 /** @internal */
-export declare const PluginModeration$outboundSchema: z.ZodType<PluginModeration$Outbound, PluginModeration>;
-export declare function pluginModerationToJSON(pluginModeration: PluginModeration): string;
+export declare const OpenResponsesRequestPluginModeration$outboundSchema: z.ZodType<OpenResponsesRequestPluginModeration$Outbound, OpenResponsesRequestPluginModeration>;
+export declare function openResponsesRequestPluginModerationToJSON(openResponsesRequestPluginModeration: OpenResponsesRequestPluginModeration): string;
 /** @internal */
-export type Plugin$Outbound = PluginModeration$Outbound | PluginWeb$Outbound | PluginFileParser$Outbound | PluginResponseHealing$Outbound;
+export type OpenResponsesRequestPluginUnion$Outbound = OpenResponsesRequestPluginModeration$Outbound | OpenResponsesRequestPluginWeb$Outbound | OpenResponsesRequestPluginFileParser$Outbound | OpenResponsesRequestPluginResponseHealing$Outbound;
 /** @internal */
-export declare const Plugin$outboundSchema: z.ZodType<Plugin$Outbound, Plugin>;
-export declare function pluginToJSON(plugin: Plugin): string;
+export declare const OpenResponsesRequestPluginUnion$outboundSchema: z.ZodType<OpenResponsesRequestPluginUnion$Outbound, OpenResponsesRequestPluginUnion>;
+export declare function openResponsesRequestPluginUnionToJSON(openResponsesRequestPluginUnion: OpenResponsesRequestPluginUnion): string;
 /** @internal */
 export type OpenResponsesRequest$Outbound = {
     input?: OpenResponsesInput$Outbound | undefined;
@@ -351,9 +385,10 @@ export type OpenResponsesRequest$Outbound = {
     service_tier: string;
     truncation?: string | null | undefined;
     stream: boolean;
-    provider?: Provider$Outbound | null | undefined;
-    plugins?: Array<PluginModeration$Outbound | PluginWeb$Outbound | PluginFileParser$Outbound | PluginResponseHealing$Outbound> | undefined;
+    provider?: OpenResponsesRequestProvider$Outbound | null | undefined;
+    plugins?: Array<OpenResponsesRequestPluginModeration$Outbound | OpenResponsesRequestPluginWeb$Outbound | OpenResponsesRequestPluginFileParser$Outbound | OpenResponsesRequestPluginResponseHealing$Outbound> | undefined;
     user?: string | undefined;
+    session_id?: string | undefined;
 };
 /** @internal */
 export declare const OpenResponsesRequest$outboundSchema: z.ZodType<OpenResponsesRequest$Outbound, OpenResponsesRequest>;

package/esm/models/openresponsesrequest.js

@@ -15,9 +15,12 @@ import { OpenResponsesWebSearch20250826Tool$outboundSchema, } from "./openrespon
 import { OpenResponsesWebSearchPreview20250311Tool$outboundSchema, } from "./openresponseswebsearchpreview20250311tool.js";
 import { OpenResponsesWebSearchPreviewTool$outboundSchema, } from "./openresponseswebsearchpreviewtool.js";
 import { OpenResponsesWebSearchTool$outboundSchema, } from "./openresponseswebsearchtool.js";
+import { PDFParserOptions$outboundSchema, } from "./pdfparseroptions.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 { WebSearchEngine$outboundSchema, } from "./websearchengine.js";
 export const ServiceTier = {
     Auto: "auto",
 };
@@ -25,15 +28,6 @@ export const Truncation = {
     Auto: "auto",
     Disabled: "disabled",
 };
-export const PdfEngine = {
-    MistralOcr: "mistral-ocr",
-    PdfText: "pdf-text",
-    Native: "native",
-};
-export const Engine = {
-    Native: "native",
-    Exa: "exa",
-};
 /** @internal */
 export const OpenResponsesRequestToolFunction$outboundSchema = z.object({
     type: z.literal("function"),
@@ -61,53 +55,64 @@ export const ServiceTier$outboundSchema = z.enum(ServiceTier);
 /** @internal */
 export const Truncation$outboundSchema = openEnums.outboundSchema(Truncation);
 /** @internal */
-export const Order$outboundSchema = z.union([
-    ProviderName$outboundSchema,
-    z.string(),
-]);
-export function orderToJSON(order) {
-    return JSON.stringify(Order$outboundSchema.parse(order));
+export const OpenResponsesRequestOrder$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
+export function openResponsesRequestOrderToJSON(openResponsesRequestOrder) {
+    return JSON.stringify(OpenResponsesRequestOrder$outboundSchema.parse(openResponsesRequestOrder));
 }
 /** @internal */
-export const Only$outboundSchema = z.union([
-    ProviderName$outboundSchema,
-    z.string(),
-]);
-export function onlyToJSON(only) {
-    return JSON.stringify(Only$outboundSchema.parse(only));
+export const OpenResponsesRequestOnly$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
+export function openResponsesRequestOnlyToJSON(openResponsesRequestOnly) {
+    return JSON.stringify(OpenResponsesRequestOnly$outboundSchema.parse(openResponsesRequestOnly));
+}
+/** @internal */
+export const OpenResponsesRequestIgnore$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
+export function openResponsesRequestIgnoreToJSON(openResponsesRequestIgnore) {
+    return JSON.stringify(OpenResponsesRequestIgnore$outboundSchema.parse(openResponsesRequestIgnore));
 }
 /** @internal */
-export const Ignore$outboundSchema = z
-    .union([ProviderName$outboundSchema, z.string()]);
-export function ignoreToJSON(ignore) {
-    return JSON.stringify(Ignore$outboundSchema.parse(ignore));
+export const OpenResponsesRequestSort$outboundSchema = z.union([
+    ProviderSort$outboundSchema,
+    ProviderSortConfig$outboundSchema,
+    z.any(),
+]);
+export function openResponsesRequestSortToJSON(openResponsesRequestSort) {
+    return JSON.stringify(OpenResponsesRequestSort$outboundSchema.parse(openResponsesRequestSort));
 }
 /** @internal */
-export const MaxPrice$outboundSchema = z
-    .object({
-    prompt: z.any().optional(),
-    completion: z.any().optional(),
-    image: z.any().optional(),
-    audio: z.any().optional(),
-    request: z.any().optional(),
+export const OpenResponsesRequestMaxPrice$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 maxPriceToJSON(maxPrice) {
-    return JSON.stringify(MaxPrice$outboundSchema.parse(maxPrice));
+export function openResponsesRequestMaxPriceToJSON(openResponsesRequestMaxPrice) {
+    return JSON.stringify(OpenResponsesRequestMaxPrice$outboundSchema.parse(openResponsesRequestMaxPrice));
 }
 /** @internal */
-export const Provider$outboundSchema = z
-    .object({
+export const OpenResponsesRequestProvider$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(),
-    order: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()]))).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()])))
+        .optional(),
     ignore: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()]))).optional(),
     quantizations: z.nullable(z.array(Quantization$outboundSchema)).optional(),
-    sort: z.nullable(ProviderSort$outboundSchema).optional(),
-    maxPrice: z.lazy(() => MaxPrice$outboundSchema).optional(),
+    sort: z.nullable(z.union([
+        ProviderSort$outboundSchema,
+        ProviderSortConfig$outboundSchema,
+        z.any(),
+    ])).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(),
 }).transform((v) => {
     return remap$(v, {
         allowFallbacks: "allow_fallbacks",
@@ -115,76 +120,64 @@ export const Provider$outboundSchema = z
         dataCollection: "data_collection",
         enforceDistillableText: "enforce_distillable_text",
         maxPrice: "max_price",
+        preferredMinThroughput: "preferred_min_throughput",
+        preferredMaxLatency: "preferred_max_latency",
+        minThroughput: "min_throughput",
+        maxLatency: "max_latency",
     });
 });
-export function providerToJSON(provider) {
-    return JSON.stringify(Provider$outboundSchema.parse(provider));
+export function openResponsesRequestProviderToJSON(openResponsesRequestProvider) {
+    return JSON.stringify(OpenResponsesRequestProvider$outboundSchema.parse(openResponsesRequestProvider));
 }
 /** @internal */
-export const PluginResponseHealing$outboundSchema = z.object({
+export const OpenResponsesRequestPluginResponseHealing$outboundSchema = z.object({
     id: z.literal("response-healing"),
+    enabled: z.boolean().optional(),
 });
-export function pluginResponseHealingToJSON(pluginResponseHealing) {
-    return JSON.stringify(PluginResponseHealing$outboundSchema.parse(pluginResponseHealing));
-}
-/** @internal */
-export const PdfEngine$outboundSchema = openEnums
-    .outboundSchema(PdfEngine);
-/** @internal */
-export const Pdf$outboundSchema = z.object({
-    engine: PdfEngine$outboundSchema.optional(),
-});
-export function pdfToJSON(pdf) {
-    return JSON.stringify(Pdf$outboundSchema.parse(pdf));
+export function openResponsesRequestPluginResponseHealingToJSON(openResponsesRequestPluginResponseHealing) {
+    return JSON.stringify(OpenResponsesRequestPluginResponseHealing$outboundSchema.parse(openResponsesRequestPluginResponseHealing));
 }
 /** @internal */
-export const PluginFileParser$outboundSchema = z.object({
+export const OpenResponsesRequestPluginFileParser$outboundSchema = z.object({
     id: z.literal("file-parser"),
-    maxFiles: z.number().optional(),
-    pdf: z.lazy(() => Pdf$outboundSchema).optional(),
-}).transform((v) => {
-    return remap$(v, {
-        maxFiles: "max_files",
-    });
+    enabled: z.boolean().optional(),
+    pdf: PDFParserOptions$outboundSchema.optional(),
 });
-export function pluginFileParserToJSON(pluginFileParser) {
-    return JSON.stringify(PluginFileParser$outboundSchema.parse(pluginFileParser));
+export function openResponsesRequestPluginFileParserToJSON(openResponsesRequestPluginFileParser) {
+    return JSON.stringify(OpenResponsesRequestPluginFileParser$outboundSchema.parse(openResponsesRequestPluginFileParser));
 }
 /** @internal */
-export const Engine$outboundSchema = openEnums
-    .outboundSchema(Engine);
-/** @internal */
-export const PluginWeb$outboundSchema = z.object({
+export const OpenResponsesRequestPluginWeb$outboundSchema = z.object({
     id: z.literal("web"),
+    enabled: z.boolean().optional(),
     maxResults: z.number().optional(),
     searchPrompt: z.string().optional(),
-    engine: Engine$outboundSchema.optional(),
+    engine: WebSearchEngine$outboundSchema.optional(),
 }).transform((v) => {
     return remap$(v, {
         maxResults: "max_results",
         searchPrompt: "search_prompt",
     });
 });
-export function pluginWebToJSON(pluginWeb) {
-    return JSON.stringify(PluginWeb$outboundSchema.parse(pluginWeb));
+export function openResponsesRequestPluginWebToJSON(openResponsesRequestPluginWeb) {
+    return JSON.stringify(OpenResponsesRequestPluginWeb$outboundSchema.parse(openResponsesRequestPluginWeb));
 }
 /** @internal */
-export const PluginModeration$outboundSchema = z.object({
+export const OpenResponsesRequestPluginModeration$outboundSchema = z.object({
     id: z.literal("moderation"),
 });
-export function pluginModerationToJSON(pluginModeration) {
-    return JSON.stringify(PluginModeration$outboundSchema.parse(pluginModeration));
+export function openResponsesRequestPluginModerationToJSON(openResponsesRequestPluginModeration) {
+    return JSON.stringify(OpenResponsesRequestPluginModeration$outboundSchema.parse(openResponsesRequestPluginModeration));
 }
 /** @internal */
-export const Plugin$outboundSchema = z
-    .union([
-    z.lazy(() => PluginModeration$outboundSchema),
-    z.lazy(() => PluginWeb$outboundSchema),
-    z.lazy(() => PluginFileParser$outboundSchema),
-    z.lazy(() => PluginResponseHealing$outboundSchema),
+export const OpenResponsesRequestPluginUnion$outboundSchema = z.union([
+    z.lazy(() => OpenResponsesRequestPluginModeration$outboundSchema),
+    z.lazy(() => OpenResponsesRequestPluginWeb$outboundSchema),
+    z.lazy(() => OpenResponsesRequestPluginFileParser$outboundSchema),
+    z.lazy(() => OpenResponsesRequestPluginResponseHealing$outboundSchema),
 ]);
-export function pluginToJSON(plugin) {
-    return JSON.stringify(Plugin$outboundSchema.parse(plugin));
+export function openResponsesRequestPluginUnionToJSON(openResponsesRequestPluginUnion) {
+    return JSON.stringify(OpenResponsesRequestPluginUnion$outboundSchema.parse(openResponsesRequestPluginUnion));
 }
 /** @internal */
 export const OpenResponsesRequest$outboundSchema = z.object({
@@ -219,14 +212,15 @@ export const OpenResponsesRequest$outboundSchema = z.object({
     serviceTier: ServiceTier$outboundSchema.default("auto"),
     truncation: z.nullable(Truncation$outboundSchema).optional(),
     stream: z.boolean().default(false),
-    provider: z.nullable(z.lazy(() => Provider$outboundSchema)).optional(),
+    provider: z.nullable(z.lazy(() => OpenResponsesRequestProvider$outboundSchema)).optional(),
     plugins: z.array(z.union([
-        z.lazy(() => PluginModeration$outboundSchema),
-        z.lazy(() => PluginWeb$outboundSchema),
-        z.lazy(() => PluginFileParser$outboundSchema),
-        z.lazy(() => PluginResponseHealing$outboundSchema),
+        z.lazy(() => OpenResponsesRequestPluginModeration$outboundSchema),
+        z.lazy(() => OpenResponsesRequestPluginWeb$outboundSchema),
+        z.lazy(() => OpenResponsesRequestPluginFileParser$outboundSchema),
+        z.lazy(() => OpenResponsesRequestPluginResponseHealing$outboundSchema),
     ])).optional(),
     user: z.string().optional(),
+    sessionId: z.string().optional(),
 }).transform((v) => {
     return remap$(v, {
         toolChoice: "tool_choice",
@@ -238,6 +232,7 @@ export const OpenResponsesRequest$outboundSchema = z.object({
         previousResponseId: "previous_response_id",
         safetyIdentifier: "safety_identifier",
         serviceTier: "service_tier",
+        sessionId: "session_id",
     });
 });
 export function openResponsesRequestToJSON(openResponsesRequest) {