@openrouter/sdk 0.2.6 → 0.2.11

package/esm/models/chatgenerationparams.js

@@ -9,15 +9,167 @@ import { Message$outboundSchema, } from "./message.js";
 import { ReasoningSummaryVerbosity$outboundSchema, } from "./reasoningsummaryverbosity.js";
 import { ResponseFormatJSONSchema$outboundSchema, } from "./responseformatjsonschema.js";
 import { ResponseFormatTextGrammar$outboundSchema, } from "./responseformattextgrammar.js";
+import { Schema0$outboundSchema, } from "./schema0.js";
 import { ToolDefinitionJson$outboundSchema, } from "./tooldefinitionjson.js";
+export const ChatGenerationParamsDataCollection = {
+    Deny: "deny",
+    Allow: "allow",
+};
+export const Quantizations = {
+    Int4: "int4",
+    Int8: "int8",
+    Fp4: "fp4",
+    Fp6: "fp6",
+    Fp8: "fp8",
+    Fp16: "fp16",
+    Bf16: "bf16",
+    Fp32: "fp32",
+    Unknown: "unknown",
+};
+export const Sort = {
+    Price: "price",
+    Throughput: "throughput",
+    Latency: "latency",
+};
+export const ChatGenerationParamsPdfEngine = {
+    MistralOcr: "mistral-ocr",
+    PdfText: "pdf-text",
+    Native: "native",
+};
+export const ChatGenerationParamsEngine = {
+    Native: "native",
+    Exa: "exa",
+};
+export const ChatGenerationParamsRoute = {
+    Fallback: "fallback",
+    Sort: "sort",
+};
 export const Effort = {
     None: "none",
     Minimal: "minimal",
     Low: "low",
     Medium: "medium",
     High: "high",
+    Xhigh: "xhigh",
 };
 /** @internal */
+export const ChatGenerationParamsDataCollection$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsDataCollection);
+/** @internal */
+export const Quantizations$outboundSchema = openEnums.outboundSchema(Quantizations);
+/** @internal */
+export const Sort$outboundSchema = openEnums
+    .outboundSchema(Sort);
+/** @internal */
+export const ChatGenerationParamsMaxPrice$outboundSchema = z.object({
+    prompt: z.any().optional(),
+    completion: z.any().optional(),
+    image: z.any().optional(),
+    audio: z.any().optional(),
+    request: z.any().optional(),
+});
+export function chatGenerationParamsMaxPriceToJSON(chatGenerationParamsMaxPrice) {
+    return JSON.stringify(ChatGenerationParamsMaxPrice$outboundSchema.parse(chatGenerationParamsMaxPrice));
+}
+/** @internal */
+export const ChatGenerationParamsProvider$outboundSchema = z.object({
+    allowFallbacks: z.nullable(z.boolean()).optional(),
+    requireParameters: z.nullable(z.boolean()).optional(),
+    dataCollection: z.nullable(ChatGenerationParamsDataCollection$outboundSchema)
+        .optional(),
+    zdr: z.nullable(z.boolean()).optional(),
+    enforceDistillableText: z.nullable(z.boolean()).optional(),
+    order: z.nullable(z.array(Schema0$outboundSchema)).optional(),
+    only: z.nullable(z.array(Schema0$outboundSchema)).optional(),
+    ignore: z.nullable(z.array(Schema0$outboundSchema)).optional(),
+    quantizations: z.nullable(z.array(Quantizations$outboundSchema)).optional(),
+    sort: z.nullable(Sort$outboundSchema).optional(),
+    maxPrice: z.lazy(() => ChatGenerationParamsMaxPrice$outboundSchema)
+        .optional(),
+    minThroughput: z.nullable(z.number()).optional(),
+    maxLatency: z.nullable(z.number()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        allowFallbacks: "allow_fallbacks",
+        requireParameters: "require_parameters",
+        dataCollection: "data_collection",
+        enforceDistillableText: "enforce_distillable_text",
+        maxPrice: "max_price",
+        minThroughput: "min_throughput",
+        maxLatency: "max_latency",
+    });
+});
+export function chatGenerationParamsProviderToJSON(chatGenerationParamsProvider) {
+    return JSON.stringify(ChatGenerationParamsProvider$outboundSchema.parse(chatGenerationParamsProvider));
+}
+/** @internal */
+export const ChatGenerationParamsPluginResponseHealing$outboundSchema = z.object({
+    id: z.literal("response-healing"),
+    enabled: z.boolean().optional(),
+});
+export function chatGenerationParamsPluginResponseHealingToJSON(chatGenerationParamsPluginResponseHealing) {
+    return JSON.stringify(ChatGenerationParamsPluginResponseHealing$outboundSchema.parse(chatGenerationParamsPluginResponseHealing));
+}
+/** @internal */
+export const ChatGenerationParamsPdfEngine$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsPdfEngine);
+/** @internal */
+export const ChatGenerationParamsPdf$outboundSchema = z.object({
+    engine: ChatGenerationParamsPdfEngine$outboundSchema.optional(),
+});
+export function chatGenerationParamsPdfToJSON(chatGenerationParamsPdf) {
+    return JSON.stringify(ChatGenerationParamsPdf$outboundSchema.parse(chatGenerationParamsPdf));
+}
+/** @internal */
+export const ChatGenerationParamsPluginFileParser$outboundSchema = z.object({
+    id: z.literal("file-parser"),
+    enabled: z.boolean().optional(),
+    maxFiles: z.number().optional(),
+    pdf: z.lazy(() => ChatGenerationParamsPdf$outboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        maxFiles: "max_files",
+    });
+});
+export function chatGenerationParamsPluginFileParserToJSON(chatGenerationParamsPluginFileParser) {
+    return JSON.stringify(ChatGenerationParamsPluginFileParser$outboundSchema.parse(chatGenerationParamsPluginFileParser));
+}
+/** @internal */
+export const ChatGenerationParamsEngine$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsEngine);
+/** @internal */
+export const ChatGenerationParamsPluginWeb$outboundSchema = z.object({
+    id: z.literal("web"),
+    enabled: z.boolean().optional(),
+    maxResults: z.number().optional(),
+    searchPrompt: z.string().optional(),
+    engine: ChatGenerationParamsEngine$outboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        maxResults: "max_results",
+        searchPrompt: "search_prompt",
+    });
+});
+export function chatGenerationParamsPluginWebToJSON(chatGenerationParamsPluginWeb) {
+    return JSON.stringify(ChatGenerationParamsPluginWeb$outboundSchema.parse(chatGenerationParamsPluginWeb));
+}
+/** @internal */
+export const ChatGenerationParamsPluginModeration$outboundSchema = z.object({
+    id: z.literal("moderation"),
+});
+export function chatGenerationParamsPluginModerationToJSON(chatGenerationParamsPluginModeration) {
+    return JSON.stringify(ChatGenerationParamsPluginModeration$outboundSchema.parse(chatGenerationParamsPluginModeration));
+}
+/** @internal */
+export const ChatGenerationParamsPluginUnion$outboundSchema = z.union([
+    z.lazy(() => ChatGenerationParamsPluginModeration$outboundSchema),
+    z.lazy(() => ChatGenerationParamsPluginWeb$outboundSchema),
+    z.lazy(() => ChatGenerationParamsPluginFileParser$outboundSchema),
+    z.lazy(() => ChatGenerationParamsPluginResponseHealing$outboundSchema),
+]);
+export function chatGenerationParamsPluginUnionToJSON(chatGenerationParamsPluginUnion) {
+    return JSON.stringify(ChatGenerationParamsPluginUnion$outboundSchema.parse(chatGenerationParamsPluginUnion));
+}
+/** @internal */
+export const ChatGenerationParamsRoute$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsRoute);
+/** @internal */
 export const Effort$outboundSchema = openEnums
     .outboundSchema(Effort);
 /** @internal */
@@ -66,7 +218,28 @@ export function chatGenerationParamsStopToJSON(chatGenerationParamsStop) {
     return JSON.stringify(ChatGenerationParamsStop$outboundSchema.parse(chatGenerationParamsStop));
 }
 /** @internal */
+export const Debug$outboundSchema = z.object({
+    echoUpstreamBody: z.boolean().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        echoUpstreamBody: "echo_upstream_body",
+    });
+});
+export function debugToJSON(debug) {
+    return JSON.stringify(Debug$outboundSchema.parse(debug));
+}
+/** @internal */
 export const ChatGenerationParams$outboundSchema = z.object({
+    provider: z.nullable(z.lazy(() => ChatGenerationParamsProvider$outboundSchema)).optional(),
+    plugins: z.array(z.union([
+        z.lazy(() => ChatGenerationParamsPluginModeration$outboundSchema),
+        z.lazy(() => ChatGenerationParamsPluginWeb$outboundSchema),
+        z.lazy(() => ChatGenerationParamsPluginFileParser$outboundSchema),
+        z.lazy(() => ChatGenerationParamsPluginResponseHealing$outboundSchema),
+    ])).optional(),
+    route: z.nullable(ChatGenerationParamsRoute$outboundSchema).optional(),
+    user: z.string().optional(),
+    sessionId: z.string().optional(),
     messages: z.array(Message$outboundSchema),
     model: z.string().optional(),
     models: z.array(z.string()).optional(),
@@ -94,9 +267,10 @@ export const ChatGenerationParams$outboundSchema = z.object({
     toolChoice: z.any().optional(),
     tools: z.array(ToolDefinitionJson$outboundSchema).optional(),
     topP: z.nullable(z.number()).optional(),
-    user: z.string().optional(),
+    debug: z.lazy(() => Debug$outboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
+        sessionId: "session_id",
         frequencyPenalty: "frequency_penalty",
         logitBias: "logit_bias",
         topLogprobs: "top_logprobs",

package/esm/models/chatmessagecontentitemaudio.d.ts

@@ -1,30 +1,15 @@
 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";
-export declare const ChatMessageContentItemAudioFormat: {
-    readonly Wav: "wav";
-    readonly Mp3: "mp3";
-    readonly Flac: "flac";
-    readonly M4a: "m4a";
-    readonly Ogg: "ogg";
-    readonly Pcm16: "pcm16";
-    readonly Pcm24: "pcm24";
-};
-export type ChatMessageContentItemAudioFormat = OpenEnum<typeof ChatMessageContentItemAudioFormat>;
 export type ChatMessageContentItemAudioInputAudio = {
     data: string;
-    format: ChatMessageContentItemAudioFormat;
+    format: string;
 };
 export type ChatMessageContentItemAudio = {
     type: "input_audio";
     inputAudio: ChatMessageContentItemAudioInputAudio;
 };
 /** @internal */
-export declare const ChatMessageContentItemAudioFormat$inboundSchema: z.ZodType<ChatMessageContentItemAudioFormat, unknown>;
-/** @internal */
-export declare const ChatMessageContentItemAudioFormat$outboundSchema: z.ZodType<string, ChatMessageContentItemAudioFormat>;
-/** @internal */
 export declare const ChatMessageContentItemAudioInputAudio$inboundSchema: z.ZodType<ChatMessageContentItemAudioInputAudio, unknown>;
 /** @internal */
 export type ChatMessageContentItemAudioInputAudio$Outbound = {

package/esm/models/chatmessagecontentitemaudio.js

@@ -4,29 +4,15 @@
 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 ChatMessageContentItemAudioFormat = {
-    Wav: "wav",
-    Mp3: "mp3",
-    Flac: "flac",
-    M4a: "m4a",
-    Ogg: "ogg",
-    Pcm16: "pcm16",
-    Pcm24: "pcm24",
-};
-/** @internal */
-export const ChatMessageContentItemAudioFormat$inboundSchema = openEnums.inboundSchema(ChatMessageContentItemAudioFormat);
-/** @internal */
-export const ChatMessageContentItemAudioFormat$outboundSchema = openEnums.outboundSchema(ChatMessageContentItemAudioFormat);
 /** @internal */
 export const ChatMessageContentItemAudioInputAudio$inboundSchema = z.object({
     data: z.string(),
-    format: ChatMessageContentItemAudioFormat$inboundSchema,
+    format: z.string(),
 });
 /** @internal */
 export const ChatMessageContentItemAudioInputAudio$outboundSchema = z.object({
     data: z.string(),
-    format: ChatMessageContentItemAudioFormat$outboundSchema,
+    format: z.string(),
 });
 export function chatMessageContentItemAudioInputAudioToJSON(chatMessageContentItemAudioInputAudio) {
     return JSON.stringify(ChatMessageContentItemAudioInputAudio$outboundSchema.parse(chatMessageContentItemAudioInputAudio));

package/esm/models/index.d.ts

@@ -128,6 +128,7 @@ export * from "./responsessearchcontextsize.js";
 export * from "./responseswebsearchcalloutput.js";
 export * from "./responseswebsearchuserlocation.js";
 export * from "./responsetextconfig.js";
+export * from "./schema0.js";
 export * from "./security.js";
 export * from "./serviceunavailableresponseerrordata.js";
 export * from "./systemmessage.js";

package/esm/models/index.js

@@ -131,6 +131,7 @@ export * from "./responsessearchcontextsize.js";
 export * from "./responseswebsearchcalloutput.js";
 export * from "./responseswebsearchuserlocation.js";
 export * from "./responsetextconfig.js";
+export * from "./schema0.js";
 export * from "./security.js";
 export * from "./serviceunavailableresponseerrordata.js";
 export * from "./systemmessage.js";

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

@@ -42,32 +42,32 @@ export type Ignore = ProviderName | string;
 /**
  * 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
      *
@@ -120,40 +120,71 @@ export type Provider = {
     /**
      * 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;
+    /**
+     * The minimum throughput (in tokens per second) required for this request. Only providers serving the model with at least this throughput will be used.
+     */
+    minThroughput?: number | null | undefined;
+    /**
+     * The maximum latency (in seconds) allowed for this request. Only providers serving the model with better than this latency will be used.
+     */
+    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: {
+export declare const OpenResponsesRequestPdfEngine: {
     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 OpenResponsesRequestPdfEngine = OpenEnum<typeof OpenResponsesRequestPdfEngine>;
+export type OpenResponsesRequestPdf = {
+    engine?: OpenResponsesRequestPdfEngine | undefined;
 };
-export type PluginFileParser = {
+export type OpenResponsesRequestPluginFileParser = {
     id: "file-parser";
+    /**
+     * Set to false to disable the file-parser plugin for this request. Defaults to true.
+     */
+    enabled?: boolean | undefined;
     maxFiles?: number | undefined;
-    pdf?: Pdf | undefined;
+    pdf?: OpenResponsesRequestPdf | undefined;
 };
-export declare const Engine: {
+export declare const OpenResponsesRequestEngine: {
     readonly Native: "native";
     readonly Exa: "exa";
 };
-export type Engine = OpenEnum<typeof Engine>;
-export type PluginWeb = {
+export type OpenResponsesRequestEngine = OpenEnum<typeof OpenResponsesRequestEngine>;
+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;
+    engine?: OpenResponsesRequestEngine | undefined;
 };
-export type PluginModeration = {
+export type OpenResponsesRequestPluginModeration = {
     id: "moderation";
 };
-export type Plugin = PluginModeration | PluginWeb | PluginFileParser | PluginResponseHealing;
+export type OpenResponsesRequestPluginUnion = OpenResponsesRequestPluginModeration | OpenResponsesRequestPluginWeb | OpenResponsesRequestPluginFileParser | OpenResponsesRequestPluginResponseHealing;
+/**
+ * Routing strategy for multiple models: "fallback" (default) uses secondary models as backups, "sort" sorts all endpoints together by routing criteria.
+ */
+export declare const OpenResponsesRequestRoute: {
+    readonly Fallback: "fallback";
+    readonly Sort: "sort";
+};
+/**
+ * Routing strategy for multiple models: "fallback" (default) uses secondary models as backups, "sort" sorts all endpoints together by routing criteria.
+ */
+export type OpenResponsesRequestRoute = OpenEnum<typeof OpenResponsesRequestRoute>;
 /**
  * Request schema for Responses endpoint
  */
@@ -199,15 +230,23 @@ 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;
+    /**
+     * Routing strategy for multiple models: "fallback" (default) uses secondary models as backups, "sort" sorts all endpoints together by routing criteria.
+     */
+    route?: OpenResponsesRequestRoute | null | 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 = {
@@ -247,18 +286,18 @@ export type Ignore$Outbound = string | string;
 export declare const Ignore$outboundSchema: z.ZodType<Ignore$Outbound, Ignore>;
 export declare function ignoreToJSON(ignore: Ignore): string;
 /** @internal */
-export type MaxPrice$Outbound = {
-    prompt?: any | undefined;
-    completion?: any | undefined;
-    image?: any | undefined;
-    audio?: any | undefined;
-    request?: any | undefined;
+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;
@@ -269,60 +308,67 @@ export type Provider$Outbound = {
     ignore?: Array<string | string> | null | undefined;
     quantizations?: Array<string> | null | undefined;
     sort?: string | null | undefined;
-    max_price?: MaxPrice$Outbound | undefined;
+    max_price?: OpenResponsesRequestMaxPrice$Outbound | 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;
+export declare const OpenResponsesRequestPluginResponseHealing$outboundSchema: z.ZodType<OpenResponsesRequestPluginResponseHealing$Outbound, OpenResponsesRequestPluginResponseHealing>;
+export declare function openResponsesRequestPluginResponseHealingToJSON(openResponsesRequestPluginResponseHealing: OpenResponsesRequestPluginResponseHealing): string;
 /** @internal */
-export declare const PdfEngine$outboundSchema: z.ZodType<string, PdfEngine>;
+export declare const OpenResponsesRequestPdfEngine$outboundSchema: z.ZodType<string, OpenResponsesRequestPdfEngine>;
 /** @internal */
-export type Pdf$Outbound = {
+export type OpenResponsesRequestPdf$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 OpenResponsesRequestPdf$outboundSchema: z.ZodType<OpenResponsesRequestPdf$Outbound, OpenResponsesRequestPdf>;
+export declare function openResponsesRequestPdfToJSON(openResponsesRequestPdf: OpenResponsesRequestPdf): string;
 /** @internal */
-export type PluginFileParser$Outbound = {
+export type OpenResponsesRequestPluginFileParser$Outbound = {
     id: "file-parser";
+    enabled?: boolean | undefined;
     max_files?: number | undefined;
-    pdf?: Pdf$Outbound | undefined;
+    pdf?: OpenResponsesRequestPdf$Outbound | undefined;
 };
 /** @internal */
-export declare const PluginFileParser$outboundSchema: z.ZodType<PluginFileParser$Outbound, PluginFileParser>;
-export declare function pluginFileParserToJSON(pluginFileParser: PluginFileParser): string;
+export declare const OpenResponsesRequestPluginFileParser$outboundSchema: z.ZodType<OpenResponsesRequestPluginFileParser$Outbound, OpenResponsesRequestPluginFileParser>;
+export declare function openResponsesRequestPluginFileParserToJSON(openResponsesRequestPluginFileParser: OpenResponsesRequestPluginFileParser): string;
 /** @internal */
-export declare const Engine$outboundSchema: z.ZodType<string, Engine>;
+export declare const OpenResponsesRequestEngine$outboundSchema: z.ZodType<string, OpenResponsesRequestEngine>;
 /** @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 OpenResponsesRequestPluginUnion$Outbound = OpenResponsesRequestPluginModeration$Outbound | OpenResponsesRequestPluginWeb$Outbound | OpenResponsesRequestPluginFileParser$Outbound | OpenResponsesRequestPluginResponseHealing$Outbound;
 /** @internal */
-export type Plugin$Outbound = PluginModeration$Outbound | PluginWeb$Outbound | PluginFileParser$Outbound | PluginResponseHealing$Outbound;
+export declare const OpenResponsesRequestPluginUnion$outboundSchema: z.ZodType<OpenResponsesRequestPluginUnion$Outbound, OpenResponsesRequestPluginUnion>;
+export declare function openResponsesRequestPluginUnionToJSON(openResponsesRequestPluginUnion: OpenResponsesRequestPluginUnion): string;
 /** @internal */
-export declare const Plugin$outboundSchema: z.ZodType<Plugin$Outbound, Plugin>;
-export declare function pluginToJSON(plugin: Plugin): string;
+export declare const OpenResponsesRequestRoute$outboundSchema: z.ZodType<string, OpenResponsesRequestRoute>;
 /** @internal */
 export type OpenResponsesRequest$Outbound = {
     input?: OpenResponsesInput$Outbound | undefined;
@@ -351,9 +397,11 @@ 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;
+    route?: string | null | undefined;
     user?: string | undefined;
+    session_id?: string | undefined;
 };
 /** @internal */
 export declare const OpenResponsesRequest$outboundSchema: z.ZodType<OpenResponsesRequest$Outbound, OpenResponsesRequest>;