@openrouter/sdk 0.2.9 → 0.3.1

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.3.1";
     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.3.1 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.3.1",
     genVersion: "2.768.0",
-    userAgent: "speakeasy-sdk/typescript 0.2.9 2.768.0 1.0.0 @openrouter/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.3.1 2.768.0 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/models/chatgenerationparams.d.ts

@@ -2,16 +2,138 @@ import * as z from "zod/v4";
 import { OpenEnum } from "../types/enums.js";
 import { ChatStreamOptions, ChatStreamOptions$Outbound } from "./chatstreamoptions.js";
 import { Message, Message$Outbound } from "./message.js";
+import { ProviderSortUnion, ProviderSortUnion$Outbound } from "./providersortunion.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>;
+/**
+ * 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?: ProviderSortUnion | 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;
+    preferredMinThroughput?: number | null | undefined;
+    preferredMaxLatency?: number | null | undefined;
+    minThroughput?: number | null | undefined;
+    maxLatency?: number | null | undefined;
+};
+export type ChatGenerationParamsPluginResponseHealing = {
+    id: "response-healing";
+    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 ChatGenerationParamsPluginFileParser = {
+    id: "file-parser";
+    enabled?: boolean | undefined;
+    pdf?: Pdf | undefined;
+};
+export declare const Engine: {
+    readonly Native: "native";
+    readonly Exa: "exa";
+};
+export type Engine = OpenEnum<typeof Engine>;
+export type ChatGenerationParamsPluginWeb = {
+    id: "web";
+    enabled?: boolean | undefined;
+    maxResults?: number | undefined;
+    searchPrompt?: string | undefined;
+    engine?: Engine | undefined;
+};
+export type ChatGenerationParamsPluginModeration = {
+    id: "moderation";
+};
+export type ChatGenerationParamsPluginUnion = ChatGenerationParamsPluginModeration | ChatGenerationParamsPluginWeb | ChatGenerationParamsPluginFileParser | ChatGenerationParamsPluginResponseHealing;
+export declare const Route: {
+    readonly Fallback: "fallback";
+    readonly Sort: "sort";
+};
+export type Route = OpenEnum<typeof Route>;
 export declare const Effort: {
-    readonly None: "none";
-    readonly Minimal: "minimal";
-    readonly Low: "low";
-    readonly Medium: "medium";
+    readonly Xhigh: "xhigh";
     readonly High: "high";
+    readonly Medium: "medium";
+    readonly Low: "low";
+    readonly Minimal: "minimal";
+    readonly None: "none";
 };
 export type Effort = OpenEnum<typeof Effort>;
 export type Reasoning = {
@@ -33,6 +155,20 @@ 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;
+    route?: Route | 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 +194,98 @@ 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 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?: ProviderSortUnion$Outbound | null | undefined;
+    max_price?: ChatGenerationParamsMaxPrice$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 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 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;
+/** @internal */
+export type ChatGenerationParamsPluginFileParser$Outbound = {
+    id: "file-parser";
+    enabled?: boolean | undefined;
+    pdf?: Pdf$Outbound | undefined;
+};
+/** @internal */
+export declare const ChatGenerationParamsPluginFileParser$outboundSchema: z.ZodType<ChatGenerationParamsPluginFileParser$Outbound, ChatGenerationParamsPluginFileParser>;
+export declare function chatGenerationParamsPluginFileParserToJSON(chatGenerationParamsPluginFileParser: ChatGenerationParamsPluginFileParser): string;
+/** @internal */
+export declare const Engine$outboundSchema: z.ZodType<string, Engine>;
+/** @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 Route$outboundSchema: z.ZodType<string, Route>;
+/** @internal */
 export declare const Effort$outboundSchema: z.ZodType<string, Effort>;
 /** @internal */
 export type Reasoning$Outbound = {
@@ -111,6 +335,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 +365,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

@@ -6,18 +6,165 @@ import { remap as remap$ } from "../lib/primitives.js";
 import * as openEnums from "../types/enums.js";
 import { ChatStreamOptions$outboundSchema, } from "./chatstreamoptions.js";
 import { Message$outboundSchema, } from "./message.js";
+import { ProviderSortUnion$outboundSchema, } from "./providersortunion.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 PdfEngine = {
+    MistralOcr: "mistral-ocr",
+    PdfText: "pdf-text",
+    Native: "native",
+};
+export const Engine = {
+    Native: "native",
+    Exa: "exa",
+};
+export const Route = {
+    Fallback: "fallback",
+    Sort: "sort",
+};
 export const Effort = {
-    None: "none",
-    Minimal: "minimal",
-    Low: "low",
-    Medium: "medium",
+    Xhigh: "xhigh",
     High: "high",
+    Medium: "medium",
+    Low: "low",
+    Minimal: "minimal",
+    None: "none",
 };
 /** @internal */
+export const ChatGenerationParamsDataCollection$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsDataCollection);
+/** @internal */
+export const Quantizations$outboundSchema = openEnums.outboundSchema(Quantizations);
+/** @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(ProviderSortUnion$outboundSchema).optional(),
+    maxPrice: z.lazy(() => ChatGenerationParamsMaxPrice$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",
+        requireParameters: "require_parameters",
+        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 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 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));
+}
+/** @internal */
+export const ChatGenerationParamsPluginFileParser$outboundSchema = z.object({
+    id: z.literal("file-parser"),
+    enabled: z.boolean().optional(),
+    pdf: z.lazy(() => Pdf$outboundSchema).optional(),
+});
+export function chatGenerationParamsPluginFileParserToJSON(chatGenerationParamsPluginFileParser) {
+    return JSON.stringify(ChatGenerationParamsPluginFileParser$outboundSchema.parse(chatGenerationParamsPluginFileParser));
+}
+/** @internal */
+export const Engine$outboundSchema = openEnums
+    .outboundSchema(Engine);
+/** @internal */
+export const ChatGenerationParamsPluginWeb$outboundSchema = z.object({
+    id: z.literal("web"),
+    enabled: z.boolean().optional(),
+    maxResults: z.number().optional(),
+    searchPrompt: z.string().optional(),
+    engine: Engine$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 Route$outboundSchema = openEnums
+    .outboundSchema(Route);
+/** @internal */
 export const Effort$outboundSchema = openEnums
     .outboundSchema(Effort);
 /** @internal */
@@ -78,6 +225,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(Route$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 +262,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/chatresponsechoice.d.ts

@@ -4,10 +4,12 @@ import { AssistantMessage } from "./assistantmessage.js";
 import { ChatCompletionFinishReason } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs } from "./chatmessagetokenlogprobs.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { Schema3 } from "./schema3.js";
 export type ChatResponseChoice = {
     finishReason: ChatCompletionFinishReason | null;
     index: number;
     message: AssistantMessage;
+    reasoningDetails?: Array<Schema3> | undefined;
     logprobs?: ChatMessageTokenLogprobs | null | undefined;
 };
 /** @internal */

package/esm/models/chatresponsechoice.js

@@ -7,15 +7,18 @@ import { safeParse } from "../lib/schemas.js";
 import { AssistantMessage$inboundSchema, } from "./assistantmessage.js";
 import { ChatCompletionFinishReason$inboundSchema, } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs$inboundSchema, } from "./chatmessagetokenlogprobs.js";
+import { Schema3$inboundSchema } from "./schema3.js";
 /** @internal */
 export const ChatResponseChoice$inboundSchema = z.object({
     finish_reason: z.nullable(ChatCompletionFinishReason$inboundSchema),
     index: z.number(),
     message: AssistantMessage$inboundSchema,
+    reasoning_details: z.array(Schema3$inboundSchema).optional(),
     logprobs: z.nullable(ChatMessageTokenLogprobs$inboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         "finish_reason": "finishReason",
+        "reasoning_details": "reasoningDetails",
     });
 });
 export function chatResponseChoiceFromJSON(jsonString) {

package/esm/models/chatstreamingmessagechunk.d.ts

@@ -3,6 +3,7 @@ import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { ChatStreamingMessageToolCall } from "./chatstreamingmessagetoolcall.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { Schema3 } from "./schema3.js";
 export declare const ChatStreamingMessageChunkRole: {
     readonly Assistant: "assistant";
 };
@@ -13,6 +14,7 @@ export type ChatStreamingMessageChunk = {
     reasoning?: string | null | undefined;
     refusal?: string | null | undefined;
     toolCalls?: Array<ChatStreamingMessageToolCall> | undefined;
+    reasoningDetails?: Array<Schema3> | undefined;
 };
 /** @internal */
 export declare const ChatStreamingMessageChunkRole$inboundSchema: z.ZodEnum<typeof ChatStreamingMessageChunkRole>;

package/esm/models/chatstreamingmessagechunk.js

@@ -5,6 +5,7 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ChatStreamingMessageToolCall$inboundSchema, } from "./chatstreamingmessagetoolcall.js";
+import { Schema3$inboundSchema } from "./schema3.js";
 export const ChatStreamingMessageChunkRole = {
     Assistant: "assistant",
 };
@@ -17,9 +18,11 @@ export const ChatStreamingMessageChunk$inboundSchema = z.object({
     reasoning: z.nullable(z.string()).optional(),
     refusal: z.nullable(z.string()).optional(),
     tool_calls: z.array(ChatStreamingMessageToolCall$inboundSchema).optional(),
+    reasoning_details: z.array(Schema3$inboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         "tool_calls": "toolCalls",
+        "reasoning_details": "reasoningDetails",
     });
 });
 export function chatStreamingMessageChunkFromJSON(jsonString) {

package/esm/models/index.d.ts

@@ -95,10 +95,15 @@ export * from "./outputmodality.js";
 export * from "./parameter.js";
 export * from "./payloadtoolargeresponseerrordata.js";
 export * from "./paymentrequiredresponseerrordata.js";
+export * from "./pdfparserengine.js";
+export * from "./pdfparseroptions.js";
 export * from "./perrequestlimits.js";
 export * from "./providername.js";
 export * from "./provideroverloadedresponseerrordata.js";
+export * from "./providerpreferences.js";
 export * from "./providersort.js";
+export * from "./providersortconfig.js";
+export * from "./providersortunion.js";
 export * from "./publicendpoint.js";
 export * from "./publicpricing.js";
 export * from "./quantization.js";
@@ -128,6 +133,8 @@ export * from "./responsessearchcontextsize.js";
 export * from "./responseswebsearchcalloutput.js";
 export * from "./responseswebsearchuserlocation.js";
 export * from "./responsetextconfig.js";
+export * from "./schema0.js";
+export * from "./schema3.js";
 export * from "./security.js";
 export * from "./serviceunavailableresponseerrordata.js";
 export * from "./systemmessage.js";
@@ -140,6 +147,7 @@ export * from "./unauthorizedresponseerrordata.js";
 export * from "./unprocessableentityresponseerrordata.js";
 export * from "./urlcitation.js";
 export * from "./usermessage.js";
+export * from "./websearchengine.js";
 export * from "./websearchpreviewtooluserlocation.js";
 export * from "./websearchstatus.js";
 //# sourceMappingURL=index.d.ts.map

package/esm/models/index.js

@@ -98,10 +98,15 @@ export * from "./outputmodality.js";
 export * from "./parameter.js";
 export * from "./payloadtoolargeresponseerrordata.js";
 export * from "./paymentrequiredresponseerrordata.js";
+export * from "./pdfparserengine.js";
+export * from "./pdfparseroptions.js";
 export * from "./perrequestlimits.js";
 export * from "./providername.js";
 export * from "./provideroverloadedresponseerrordata.js";
+export * from "./providerpreferences.js";
 export * from "./providersort.js";
+export * from "./providersortconfig.js";
+export * from "./providersortunion.js";
 export * from "./publicendpoint.js";
 export * from "./publicpricing.js";
 export * from "./quantization.js";
@@ -131,6 +136,8 @@ export * from "./responsessearchcontextsize.js";
 export * from "./responseswebsearchcalloutput.js";
 export * from "./responseswebsearchuserlocation.js";
 export * from "./responsetextconfig.js";
+export * from "./schema0.js";
+export * from "./schema3.js";
 export * from "./security.js";
 export * from "./serviceunavailableresponseerrordata.js";
 export * from "./systemmessage.js";
@@ -143,6 +150,7 @@ export * from "./unauthorizedresponseerrordata.js";
 export * from "./unprocessableentityresponseerrordata.js";
 export * from "./urlcitation.js";
 export * from "./usermessage.js";
+export * from "./websearchengine.js";
 export * from "./websearchpreviewtooluserlocation.js";
 export * from "./websearchstatus.js";
 //# sourceMappingURL=index.js.map