@openrouter/sdk 0.2.9 → 0.2.11

package/esm/funcs/embeddingsGenerate.js

@@ -29,7 +29,7 @@ async function $do(client, request, options) {
     const path = pathToFunc("/embeddings")();
     const headers = new Headers(compactMap({
         "Content-Type": "application/json",
-        Accept: "application/json",
+        Accept: "application/json;q=1, text/event-stream;q=0",
     }));
     const secConfig = await extractSecurity(client._options.apiKey);
     const securityInput = secConfig == null ? {} : { apiKey: secConfig };
@@ -86,7 +86,9 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.CreateEmbeddingsResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(402, errors.PaymentRequiredResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(429, errors.TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.jsonErr(502, errors.BadGatewayResponseError$inboundSchema), M.jsonErr(503, errors.ServiceUnavailableResponseError$inboundSchema), M.jsonErr(524, errors.EdgeNetworkTimeoutResponseError$inboundSchema), M.jsonErr(529, errors.ProviderOverloadedResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, operations.CreateEmbeddingsResponse$inboundSchema), M.text(200, operations.CreateEmbeddingsResponse$inboundSchema, {
+        ctype: "text/event-stream",
+    }), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(402, errors.PaymentRequiredResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(429, errors.TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.jsonErr(502, errors.BadGatewayResponseError$inboundSchema), M.jsonErr(503, errors.ServiceUnavailableResponseError$inboundSchema), M.jsonErr(524, errors.EdgeNetworkTimeoutResponseError$inboundSchema), M.jsonErr(529, errors.ProviderOverloadedResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/lib/config.d.ts

@@ -45,8 +45,8 @@ export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "0.2.9";
+    readonly sdkVersion: "0.2.11";
     readonly genVersion: "2.768.0";
-    readonly userAgent: "speakeasy-sdk/typescript 0.2.9 2.768.0 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.2.11 2.768.0 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

@@ -25,8 +25,8 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.2.9",
+    sdkVersion: "0.2.11",
     genVersion: "2.768.0",
-    userAgent: "speakeasy-sdk/typescript 0.2.9 2.768.0 1.0.0 @openrouter/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.2.11 2.768.0 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/models/chatgenerationparams.d.ts

@@ -5,13 +5,145 @@ import { Message, Message$Outbound } from "./message.js";
 import { ReasoningSummaryVerbosity } from "./reasoningsummaryverbosity.js";
 import { ResponseFormatJSONSchema, ResponseFormatJSONSchema$Outbound } from "./responseformatjsonschema.js";
 import { ResponseFormatTextGrammar, ResponseFormatTextGrammar$Outbound } from "./responseformattextgrammar.js";
+import { Schema0, Schema0$Outbound } from "./schema0.js";
 import { ToolDefinitionJson, ToolDefinitionJson$Outbound } from "./tooldefinitionjson.js";
+export declare const ChatGenerationParamsDataCollection: {
+    readonly Deny: "deny";
+    readonly Allow: "allow";
+};
+export type ChatGenerationParamsDataCollection = OpenEnum<typeof ChatGenerationParamsDataCollection>;
+export declare const Quantizations: {
+    readonly Int4: "int4";
+    readonly Int8: "int8";
+    readonly Fp4: "fp4";
+    readonly Fp6: "fp6";
+    readonly Fp8: "fp8";
+    readonly Fp16: "fp16";
+    readonly Bf16: "bf16";
+    readonly Fp32: "fp32";
+    readonly Unknown: "unknown";
+};
+export type Quantizations = OpenEnum<typeof Quantizations>;
+export declare const Sort: {
+    readonly Price: "price";
+    readonly Throughput: "throughput";
+    readonly Latency: "latency";
+};
+export type Sort = OpenEnum<typeof Sort>;
+/**
+ * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
+ */
+export type ChatGenerationParamsMaxPrice = {
+    prompt?: any | undefined;
+    completion?: any | undefined;
+    image?: any | undefined;
+    audio?: any | undefined;
+    request?: any | undefined;
+};
+export type ChatGenerationParamsProvider = {
+    /**
+     * Whether to allow backup providers to serve requests
+     *
+     * @remarks
+     * - true: (default) when the primary provider (or your custom providers in "order") is unavailable, use the next best provider.
+     * - false: use only the primary/custom provider, and return the upstream error if it's unavailable.
+     */
+    allowFallbacks?: boolean | null | undefined;
+    /**
+     * Whether to filter providers to only those that support the parameters you've provided. If this setting is omitted or set to false, then providers will receive only the parameters they support, and ignore the rest.
+     */
+    requireParameters?: boolean | null | undefined;
+    /**
+     * 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.
+     */
+    dataCollection?: ChatGenerationParamsDataCollection | null | undefined;
+    zdr?: boolean | null | undefined;
+    enforceDistillableText?: boolean | null | undefined;
+    /**
+     * An ordered list of provider slugs. The router will attempt to use the first provider in the subset of this list that supports your requested model, and fall back to the next if it is unavailable. If no providers are available, the request will fail with an error message.
+     */
+    order?: Array<Schema0> | null | undefined;
+    /**
+     * List of provider slugs to allow. If provided, this list is merged with your account-wide allowed provider settings for this request.
+     */
+    only?: Array<Schema0> | null | undefined;
+    /**
+     * List of provider slugs to ignore. If provided, this list is merged with your account-wide ignored provider settings for this request.
+     */
+    ignore?: Array<Schema0> | null | undefined;
+    /**
+     * A list of quantization levels to filter the provider by.
+     */
+    quantizations?: Array<Quantizations> | null | undefined;
+    /**
+     * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
+     */
+    sort?: Sort | 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?: ChatGenerationParamsMaxPrice | 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 ChatGenerationParamsPluginResponseHealing = {
+    id: "response-healing";
+    enabled?: boolean | undefined;
+};
+export declare const ChatGenerationParamsPdfEngine: {
+    readonly MistralOcr: "mistral-ocr";
+    readonly PdfText: "pdf-text";
+    readonly Native: "native";
+};
+export type ChatGenerationParamsPdfEngine = OpenEnum<typeof ChatGenerationParamsPdfEngine>;
+export type ChatGenerationParamsPdf = {
+    engine?: ChatGenerationParamsPdfEngine | undefined;
+};
+export type ChatGenerationParamsPluginFileParser = {
+    id: "file-parser";
+    enabled?: boolean | undefined;
+    maxFiles?: number | undefined;
+    pdf?: ChatGenerationParamsPdf | undefined;
+};
+export declare const ChatGenerationParamsEngine: {
+    readonly Native: "native";
+    readonly Exa: "exa";
+};
+export type ChatGenerationParamsEngine = OpenEnum<typeof ChatGenerationParamsEngine>;
+export type ChatGenerationParamsPluginWeb = {
+    id: "web";
+    enabled?: boolean | undefined;
+    maxResults?: number | undefined;
+    searchPrompt?: string | undefined;
+    engine?: ChatGenerationParamsEngine | undefined;
+};
+export type ChatGenerationParamsPluginModeration = {
+    id: "moderation";
+};
+export type ChatGenerationParamsPluginUnion = ChatGenerationParamsPluginModeration | ChatGenerationParamsPluginWeb | ChatGenerationParamsPluginFileParser | ChatGenerationParamsPluginResponseHealing;
+export declare const ChatGenerationParamsRoute: {
+    readonly Fallback: "fallback";
+    readonly Sort: "sort";
+};
+export type ChatGenerationParamsRoute = OpenEnum<typeof ChatGenerationParamsRoute>;
 export declare const Effort: {
     readonly None: "none";
     readonly Minimal: "minimal";
     readonly Low: "low";
     readonly Medium: "medium";
     readonly High: "high";
+    readonly Xhigh: "xhigh";
 };
 export type Effort = OpenEnum<typeof Effort>;
 export type Reasoning = {
@@ -33,6 +165,23 @@ export type Debug = {
     echoUpstreamBody?: boolean | undefined;
 };
 export type ChatGenerationParams = {
+    /**
+     * When multiple model providers are available, optionally indicate your routing preference.
+     */
+    provider?: ChatGenerationParamsProvider | null | undefined;
+    /**
+     * Plugins you want to enable for this request, including their settings.
+     */
+    plugins?: Array<ChatGenerationParamsPluginModeration | ChatGenerationParamsPluginWeb | ChatGenerationParamsPluginFileParser | ChatGenerationParamsPluginResponseHealing> | undefined;
+    /**
+     * Routing strategy for multiple models: "fallback" (default) uses secondary models as backups, "sort" sorts all endpoints together by routing criteria.
+     */
+    route?: ChatGenerationParamsRoute | null | undefined;
+    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;
     messages: Array<Message>;
     model?: string | undefined;
     models?: Array<string> | undefined;
@@ -58,10 +207,99 @@ export type ChatGenerationParams = {
     toolChoice?: any | undefined;
     tools?: Array<ToolDefinitionJson> | undefined;
     topP?: number | null | undefined;
-    user?: string | undefined;
     debug?: Debug | undefined;
 };
 /** @internal */
+export declare const ChatGenerationParamsDataCollection$outboundSchema: z.ZodType<string, ChatGenerationParamsDataCollection>;
+/** @internal */
+export declare const Quantizations$outboundSchema: z.ZodType<string, Quantizations>;
+/** @internal */
+export declare const Sort$outboundSchema: z.ZodType<string, Sort>;
+/** @internal */
+export type ChatGenerationParamsMaxPrice$Outbound = {
+    prompt?: any | undefined;
+    completion?: any | undefined;
+    image?: any | undefined;
+    audio?: any | undefined;
+    request?: any | undefined;
+};
+/** @internal */
+export declare const ChatGenerationParamsMaxPrice$outboundSchema: z.ZodType<ChatGenerationParamsMaxPrice$Outbound, ChatGenerationParamsMaxPrice>;
+export declare function chatGenerationParamsMaxPriceToJSON(chatGenerationParamsMaxPrice: ChatGenerationParamsMaxPrice): string;
+/** @internal */
+export type ChatGenerationParamsProvider$Outbound = {
+    allow_fallbacks?: boolean | null | undefined;
+    require_parameters?: boolean | null | undefined;
+    data_collection?: string | null | undefined;
+    zdr?: boolean | null | undefined;
+    enforce_distillable_text?: boolean | null | undefined;
+    order?: Array<Schema0$Outbound> | null | undefined;
+    only?: Array<Schema0$Outbound> | null | undefined;
+    ignore?: Array<Schema0$Outbound> | null | undefined;
+    quantizations?: Array<string> | null | undefined;
+    sort?: string | null | undefined;
+    max_price?: ChatGenerationParamsMaxPrice$Outbound | undefined;
+    min_throughput?: number | null | undefined;
+    max_latency?: number | null | undefined;
+};
+/** @internal */
+export declare const ChatGenerationParamsProvider$outboundSchema: z.ZodType<ChatGenerationParamsProvider$Outbound, ChatGenerationParamsProvider>;
+export declare function chatGenerationParamsProviderToJSON(chatGenerationParamsProvider: ChatGenerationParamsProvider): string;
+/** @internal */
+export type ChatGenerationParamsPluginResponseHealing$Outbound = {
+    id: "response-healing";
+    enabled?: boolean | undefined;
+};
+/** @internal */
+export declare const ChatGenerationParamsPluginResponseHealing$outboundSchema: z.ZodType<ChatGenerationParamsPluginResponseHealing$Outbound, ChatGenerationParamsPluginResponseHealing>;
+export declare function chatGenerationParamsPluginResponseHealingToJSON(chatGenerationParamsPluginResponseHealing: ChatGenerationParamsPluginResponseHealing): string;
+/** @internal */
+export declare const ChatGenerationParamsPdfEngine$outboundSchema: z.ZodType<string, ChatGenerationParamsPdfEngine>;
+/** @internal */
+export type ChatGenerationParamsPdf$Outbound = {
+    engine?: string | undefined;
+};
+/** @internal */
+export declare const ChatGenerationParamsPdf$outboundSchema: z.ZodType<ChatGenerationParamsPdf$Outbound, ChatGenerationParamsPdf>;
+export declare function chatGenerationParamsPdfToJSON(chatGenerationParamsPdf: ChatGenerationParamsPdf): string;
+/** @internal */
+export type ChatGenerationParamsPluginFileParser$Outbound = {
+    id: "file-parser";
+    enabled?: boolean | undefined;
+    max_files?: number | undefined;
+    pdf?: ChatGenerationParamsPdf$Outbound | undefined;
+};
+/** @internal */
+export declare const ChatGenerationParamsPluginFileParser$outboundSchema: z.ZodType<ChatGenerationParamsPluginFileParser$Outbound, ChatGenerationParamsPluginFileParser>;
+export declare function chatGenerationParamsPluginFileParserToJSON(chatGenerationParamsPluginFileParser: ChatGenerationParamsPluginFileParser): string;
+/** @internal */
+export declare const ChatGenerationParamsEngine$outboundSchema: z.ZodType<string, ChatGenerationParamsEngine>;
+/** @internal */
+export type ChatGenerationParamsPluginWeb$Outbound = {
+    id: "web";
+    enabled?: boolean | undefined;
+    max_results?: number | undefined;
+    search_prompt?: string | undefined;
+    engine?: string | undefined;
+};
+/** @internal */
+export declare const ChatGenerationParamsPluginWeb$outboundSchema: z.ZodType<ChatGenerationParamsPluginWeb$Outbound, ChatGenerationParamsPluginWeb>;
+export declare function chatGenerationParamsPluginWebToJSON(chatGenerationParamsPluginWeb: ChatGenerationParamsPluginWeb): string;
+/** @internal */
+export type ChatGenerationParamsPluginModeration$Outbound = {
+    id: "moderation";
+};
+/** @internal */
+export declare const ChatGenerationParamsPluginModeration$outboundSchema: z.ZodType<ChatGenerationParamsPluginModeration$Outbound, ChatGenerationParamsPluginModeration>;
+export declare function chatGenerationParamsPluginModerationToJSON(chatGenerationParamsPluginModeration: ChatGenerationParamsPluginModeration): string;
+/** @internal */
+export type ChatGenerationParamsPluginUnion$Outbound = ChatGenerationParamsPluginModeration$Outbound | ChatGenerationParamsPluginWeb$Outbound | ChatGenerationParamsPluginFileParser$Outbound | ChatGenerationParamsPluginResponseHealing$Outbound;
+/** @internal */
+export declare const ChatGenerationParamsPluginUnion$outboundSchema: z.ZodType<ChatGenerationParamsPluginUnion$Outbound, ChatGenerationParamsPluginUnion>;
+export declare function chatGenerationParamsPluginUnionToJSON(chatGenerationParamsPluginUnion: ChatGenerationParamsPluginUnion): string;
+/** @internal */
+export declare const ChatGenerationParamsRoute$outboundSchema: z.ZodType<string, ChatGenerationParamsRoute>;
+/** @internal */
 export declare const Effort$outboundSchema: z.ZodType<string, Effort>;
 /** @internal */
 export type Reasoning$Outbound = {
@@ -111,6 +349,11 @@ export declare const Debug$outboundSchema: z.ZodType<Debug$Outbound, Debug>;
 export declare function debugToJSON(debug: Debug): string;
 /** @internal */
 export type ChatGenerationParams$Outbound = {
+    provider?: ChatGenerationParamsProvider$Outbound | null | undefined;
+    plugins?: Array<ChatGenerationParamsPluginModeration$Outbound | ChatGenerationParamsPluginWeb$Outbound | ChatGenerationParamsPluginFileParser$Outbound | ChatGenerationParamsPluginResponseHealing$Outbound> | undefined;
+    route?: string | null | undefined;
+    user?: string | undefined;
+    session_id?: string | undefined;
     messages: Array<Message$Outbound>;
     model?: string | undefined;
     models?: Array<string> | undefined;
@@ -136,7 +379,6 @@ export type ChatGenerationParams$Outbound = {
     tool_choice?: any | undefined;
     tools?: Array<ToolDefinitionJson$Outbound> | undefined;
     top_p?: number | null | undefined;
-    user?: string | undefined;
     debug?: Debug$Outbound | undefined;
 };
 /** @internal */

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 */
@@ -78,6 +230,16 @@ export function debugToJSON(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(),
@@ -105,10 +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/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",