@openrouter/sdk 0.1.6 → 0.1.8

package/README.md

@@ -73,7 +73,7 @@ const result = await openRouter.chat.send({
       content: "Hello, how are you?",
     },
   ],
-  model: "openai/gpt-5"
+  model: "openai/gpt-5",
   provider: {
     zdr: true,
     sort: "price",
@@ -81,8 +81,8 @@ const result = await openRouter.chat.send({
   stream: true
 });
 
-for await (const chunk of stream) {
-  console.log(hunk.choices[0].delta.content)
+for await (const chunk of result) {
+  console.log(chunk.choices[0].delta.content)
 }
 
 ```

package/esm/funcs/{modelsListEmbeddings.d.ts → embeddingsListModels.d.ts}

@@ -14,5 +14,5 @@ import { Result } from "../types/fp.js";
  * @remarks
  * Returns a list of all available embeddings models and their properties
  */
-export declare function modelsListEmbeddings(client: OpenRouterCore, options?: RequestOptions): APIPromise<Result<models.ModelsListResponse, errors.BadRequestResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
-//# sourceMappingURL=modelsListEmbeddings.d.ts.map
+export declare function embeddingsListModels(client: OpenRouterCore, options?: RequestOptions): APIPromise<Result<models.ModelsListResponse, errors.BadRequestResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+//# sourceMappingURL=embeddingsListModels.d.ts.map

package/esm/funcs/{modelsListEmbeddings.js → embeddingsListModels.js}

@@ -14,11 +14,11 @@ import { APIPromise } from "../types/async.js";
  * @remarks
  * Returns a list of all available embeddings models and their properties
  */
-export function modelsListEmbeddings(client, options) {
+export function embeddingsListModels(client, options) {
     return new APIPromise($do(client, options));
 }
 async function $do(client, options) {
-    const path = pathToFunc("/models/embeddings")();
+    const path = pathToFunc("/embeddings/models")();
     const headers = new Headers(compactMap({
         Accept: "application/json",
     }));
@@ -28,7 +28,7 @@ async function $do(client, options) {
     const context = {
         options: client._options,
         baseURL: options?.serverURL ?? client._baseURL ?? "",
-        operationID: "listModelsEmbeddings",
+        operationID: "listEmbeddingsModels",
         oAuth2Scopes: null,
         resolvedSecurity: requestSecurity,
         securitySource: client._options.apiKey,
@@ -69,4 +69,4 @@ async function $do(client, options) {
     }
     return [result, { status: "complete", request: req, response }];
 }
-//# sourceMappingURL=modelsListEmbeddings.js.map
+//# sourceMappingURL=embeddingsListModels.js.map

package/esm/lib/base64.d.ts

@@ -5,6 +5,6 @@ export declare function stringToBytes(str: string): Uint8Array;
 export declare function stringFromBytes(u8arr: Uint8Array): string;
 export declare function stringToBase64(str: string): string;
 export declare function stringFromBase64(b64str: string): string;
-export declare const zodOutbound: z.ZodUnion<[z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodPipe<z.ZodString, z.ZodTransform<Uint8Array<ArrayBufferLike>, string>>]>;
-export declare const zodInbound: z.ZodUnion<[z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodPipe<z.ZodString, z.ZodTransform<Uint8Array<ArrayBufferLike>, string>>]>;
+export declare const zodOutbound: z.ZodUnion<[z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>, z.ZodPipe<z.ZodString, z.ZodTransform<Uint8Array<ArrayBufferLike>, string>>]>;
+export declare const zodInbound: z.ZodUnion<[z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>, z.ZodPipe<z.ZodString, z.ZodTransform<Uint8Array<ArrayBufferLike>, string>>]>;
 //# sourceMappingURL=base64.d.ts.map

package/esm/lib/base64.js

@@ -20,10 +20,8 @@ export function stringToBase64(str) {
 export function stringFromBase64(b64str) {
     return stringFromBytes(bytesFromBase64(b64str));
 }
-export const zodOutbound = z
-    .instanceof(Uint8Array)
+export const zodOutbound = z.custom(x => x instanceof Uint8Array)
     .or(z.string().transform(stringToBytes));
-export const zodInbound = z
-    .instanceof(Uint8Array)
+export const zodInbound = z.custom(x => x instanceof Uint8Array)
     .or(z.string().transform(bytesFromBase64));
 //# sourceMappingURL=base64.js.map

package/esm/lib/config.d.ts

@@ -37,8 +37,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.1.6";
-    readonly genVersion: "2.745.2";
-    readonly userAgent: "speakeasy-sdk/typescript 0.1.6 2.745.2 1.0.0 @openrouter/sdk";
+    readonly sdkVersion: "0.1.8";
+    readonly genVersion: "2.748.0";
+    readonly userAgent: "speakeasy-sdk/typescript 0.1.8 2.748.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.1.6",
-    genVersion: "2.745.2",
-    userAgent: "speakeasy-sdk/typescript 0.1.6 2.745.2 1.0.0 @openrouter/sdk",
+    sdkVersion: "0.1.8",
+    genVersion: "2.748.0",
+    userAgent: "speakeasy-sdk/typescript 0.1.8 2.748.0 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/lib/schemas.d.ts

@@ -13,7 +13,7 @@ export declare function parse<Inp, Out>(rawValue: Inp, fn: (value: Inp) => Out,
  * leak Zod implementation details to user code.
  */
 export declare function safeParse<Inp, Out>(rawValue: Inp, fn: (value: Inp) => Out, errorMessage: string): Result<Out, SDKValidationError>;
-export declare function collectExtraKeys<Shape extends z.ZodRawShape, Catchall extends z.ZodType, K extends string, Optional extends boolean>(obj: z.ZodObject<Shape, z.core.$catchall<Catchall>>, extrasKey: K, optional: Optional): z.ZodPipe<z.ZodObject<Shape, z.core.$catchall<Catchall>>, z.ZodTransform<z.output<z.ZodObject<Shape, z.core.$strip>> & (Optional extends true ? {
+export declare function collectExtraKeys<Shape extends z.ZodRawShape, Catchall extends z.ZodType, K extends string, Optional extends boolean>(obj: z.ZodObject<Shape, z.core.$catchall<Catchall>>, extrasKey: K, optional: Optional): z.ZodPipe<z.ZodObject<Shape, z.core.$catchall<Catchall>>, z.ZodTransform<z.output<z.ZodObject<Shape, z.core.$strip>> & (Optional extends false ? {
     [k in K]: Record<string, z.output<Catchall>>;
 } : {
     [k in K]?: Record<string, z.output<Catchall>> | undefined;

package/esm/lib/schemas.js

@@ -1,7 +1,7 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
-import { ZodError } from "zod/v4";
+import * as z from "zod/v4";
 import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
 import { ERR, OK } from "../types/fp.js";
 /**
@@ -14,7 +14,7 @@ export function parse(rawValue, fn, errorMessage) {
         return fn(rawValue);
     }
     catch (err) {
-        if (err instanceof ZodError) {
+        if (err instanceof z.ZodError) {
             throw new SDKValidationError(errorMessage, err, rawValue);
         }
         throw err;

package/esm/models/badgatewayresponseerrordata.js

@@ -5,7 +5,7 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const BadGatewayResponseErrorData$inboundSchema = z.object({
-    code: z.number().int(),
+    code: z.int(),
     message: z.string(),
     metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
 });

package/esm/models/badrequestresponseerrordata.js

@@ -5,7 +5,7 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const BadRequestResponseErrorData$inboundSchema = z.object({
-    code: z.number().int(),
+    code: z.int(),
     message: z.string(),
     metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
 });

package/esm/models/chatgenerationparams.js

@@ -86,7 +86,7 @@ export const ChatGenerationParams$outboundSchema = z.object({
         z.lazy(() => ChatGenerationParamsResponseFormatJSONObject$outboundSchema),
         z.lazy(() => ChatGenerationParamsResponseFormatPython$outboundSchema),
     ]).optional(),
-    seed: z.nullable(z.number().int()).optional(),
+    seed: z.nullable(z.int()).optional(),
     stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),
     stream: z.boolean().default(false),
     streamOptions: z.nullable(ChatStreamOptions$outboundSchema).optional(),

package/esm/models/chatmessagecontentitem.js

@@ -9,29 +9,17 @@ import { ChatMessageContentItemText$inboundSchema, ChatMessageContentItemText$ou
 import { ChatMessageContentItemVideo$inboundSchema, ChatMessageContentItemVideo$outboundSchema, } from "./chatmessagecontentitemvideo.js";
 /** @internal */
 export const ChatMessageContentItem$inboundSchema = z.union([
-    ChatMessageContentItemText$inboundSchema.and(z.object({ type: z.literal("text") }).transform((v) => ({ type: v.type }))),
-    ChatMessageContentItemImage$inboundSchema.and(z.object({ type: z.literal("image_url") }).transform((v) => ({
-        type: v.type,
-    }))),
-    ChatMessageContentItemAudio$inboundSchema.and(z.object({ type: z.literal("input_audio") }).transform((v) => ({
-        type: v.type,
-    }))),
-    ChatMessageContentItemVideo$inboundSchema.and(z.object({ type: z.literal("input_video") }).transform((v) => ({
-        type: v.type,
-    }))),
+    ChatMessageContentItemText$inboundSchema.and(z.object({ type: z.literal("text") })),
+    ChatMessageContentItemImage$inboundSchema.and(z.object({ type: z.literal("image_url") })),
+    ChatMessageContentItemAudio$inboundSchema.and(z.object({ type: z.literal("input_audio") })),
+    ChatMessageContentItemVideo$inboundSchema.and(z.object({ type: z.literal("input_video") })),
 ]);
 /** @internal */
 export const ChatMessageContentItem$outboundSchema = z.union([
-    ChatMessageContentItemText$outboundSchema.and(z.object({ type: z.literal("text") }).transform((v) => ({ type: v.type }))),
-    ChatMessageContentItemImage$outboundSchema.and(z.object({ type: z.literal("image_url") }).transform((v) => ({
-        type: v.type,
-    }))),
-    ChatMessageContentItemAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") }).transform((v) => ({
-        type: v.type,
-    }))),
-    ChatMessageContentItemVideo$outboundSchema.and(z.object({ type: z.literal("input_video") }).transform((v) => ({
-        type: v.type,
-    }))),
+    ChatMessageContentItemText$outboundSchema.and(z.object({ type: z.literal("text") })),
+    ChatMessageContentItemImage$outboundSchema.and(z.object({ type: z.literal("image_url") })),
+    ChatMessageContentItemAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") })),
+    ChatMessageContentItemVideo$outboundSchema.and(z.object({ type: z.literal("input_video") })),
 ]);
 export function chatMessageContentItemToJSON(chatMessageContentItem) {
     return JSON.stringify(ChatMessageContentItem$outboundSchema.parse(chatMessageContentItem));

package/esm/models/completioncreateparams.js

@@ -74,15 +74,15 @@ export const CompletionCreateParams$outboundSchema = z.object({
         z.array(z.number()),
         z.array(z.array(z.number())),
     ]),
-    bestOf: z.nullable(z.number().int()).optional(),
+    bestOf: z.nullable(z.int()).optional(),
     echo: z.nullable(z.boolean()).optional(),
     frequencyPenalty: z.nullable(z.number()).optional(),
     logitBias: z.nullable(z.record(z.string(), z.number())).optional(),
-    logprobs: z.nullable(z.number().int()).optional(),
-    maxTokens: z.nullable(z.number().int()).optional(),
-    n: z.nullable(z.number().int()).optional(),
+    logprobs: z.nullable(z.int()).optional(),
+    maxTokens: z.nullable(z.int()).optional(),
+    n: z.nullable(z.int()).optional(),
     presencePenalty: z.nullable(z.number()).optional(),
-    seed: z.nullable(z.number().int()).optional(),
+    seed: z.nullable(z.int()).optional(),
     stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),
     stream: z.boolean().default(false),
     streamOptions: z.nullable(z.lazy(() => StreamOptions$outboundSchema))

package/esm/models/edgenetworktimeoutresponseerrordata.js

@@ -5,7 +5,7 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const EdgeNetworkTimeoutResponseErrorData$inboundSchema = z.object({
-    code: z.number().int(),
+    code: z.int(),
     message: z.string(),
     metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
 });

package/esm/models/errors/responsevalidationerror.js

@@ -1,7 +1,7 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
-import * as z from "zod/v4";
+import * as z from "zod/v4/core";
 import { OpenRouterError } from "./openroutererror.js";
 import { formatZodError } from "./sdkvalidationerror.js";
 export class ResponseValidationError extends OpenRouterError {
@@ -18,7 +18,7 @@ export class ResponseValidationError extends OpenRouterError {
      * default error message.
      */
     pretty() {
-        if (this.cause instanceof z.ZodError) {
+        if (this.cause instanceof z.$ZodError) {
             return `${this.rawMessage}\n${formatZodError(this.cause)}`;
         }
         else {

package/esm/models/errors/sdkvalidationerror.d.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as z from "zod/v4/core";
 export declare class SDKValidationError extends Error {
     /**
      * The raw value that failed validation.
@@ -17,5 +17,5 @@ export declare class SDKValidationError extends Error {
      */
     pretty(): string;
 }
-export declare function formatZodError(err: z.ZodError): string;
+export declare function formatZodError(err: z.$ZodError): string;
 //# sourceMappingURL=sdkvalidationerror.d.ts.map

package/esm/models/errors/sdkvalidationerror.js

@@ -1,7 +1,7 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
-import * as z from "zod/v4";
+import * as z from "zod/v4/core";
 export class SDKValidationError extends Error {
     // Allows for backwards compatibility for `instanceof` checks of `ResponseValidationError`
     static [Symbol.hasInstance](instance) {
@@ -30,7 +30,7 @@ export class SDKValidationError extends Error {
      * default error message.
      */
     pretty() {
-        if (this.cause instanceof z.ZodError) {
+        if (this.cause instanceof z.$ZodError) {
             return `${this.rawMessage}\n${formatZodError(this.cause)}`;
         }
         else {

package/esm/models/forbiddenresponseerrordata.js

@@ -5,7 +5,7 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const ForbiddenResponseErrorData$inboundSchema = z.object({
-    code: z.number().int(),
+    code: z.int(),
     message: z.string(),
     metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
 });

package/esm/models/internalserverresponseerrordata.js

@@ -5,7 +5,7 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const InternalServerResponseErrorData$inboundSchema = z.object({
-    code: z.number().int(),
+    code: z.int(),
     message: z.string(),
     metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
 });

package/esm/models/notfoundresponseerrordata.js

@@ -5,7 +5,7 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const NotFoundResponseErrorData$inboundSchema = z.object({
-    code: z.number().int(),
+    code: z.int(),
     message: z.string(),
     metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
 });

package/esm/models/openairesponsesinputunion.d.ts

@@ -124,8 +124,8 @@ export type OpenAIResponsesInputMessage1 = {
         type: "input_file";
     })> | string;
 };
-export type OpenAIResponsesInputUnion1 = OpenAIResponsesInputFunctionCallOutput | OpenAIResponsesInputFunctionCall | OutputItemImageGenerationCall | OutputMessage | OpenAIResponsesInputMessage2 | OpenAIResponsesInputMessage1;
-export type OpenAIResponsesInputUnion = string | Array<OpenAIResponsesInputFunctionCallOutput | OpenAIResponsesInputFunctionCall | OutputItemImageGenerationCall | OutputMessage | OpenAIResponsesInputMessage2 | OpenAIResponsesInputMessage1> | any;
+export type OpenAIResponsesInputUnion1 = OpenAIResponsesInputFunctionCallOutput | OpenAIResponsesInputFunctionCall | OutputMessage | OpenAIResponsesInputMessage2 | OutputItemImageGenerationCall | OpenAIResponsesInputMessage1;
+export type OpenAIResponsesInputUnion = string | Array<OpenAIResponsesInputFunctionCallOutput | OpenAIResponsesInputFunctionCall | OutputMessage | OpenAIResponsesInputMessage2 | OutputItemImageGenerationCall | OpenAIResponsesInputMessage1> | any;
 /** @internal */
 export declare const OpenAIResponsesInputTypeFunctionCall$inboundSchema: z.ZodEnum<typeof OpenAIResponsesInputTypeFunctionCall>;
 /** @internal */

package/esm/models/openairesponsesinputunion.js

@@ -98,18 +98,10 @@ export function openAIResponsesInputRoleUnion2FromJSON(jsonString) {
 }
 /** @internal */
 export const OpenAIResponsesInputContent3$inboundSchema = z.union([
-    ResponseInputText$inboundSchema.and(z.object({ type: z.literal("input_text") }).transform((v) => ({
-        type: v.type,
-    }))),
-    ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") }).transform((v) => ({
-        type: v.type,
-    }))),
-    ResponseInputAudio$inboundSchema.and(z.object({ type: z.literal("input_audio") }).transform((v) => ({
-        type: v.type,
-    }))),
-    ResponseInputFile$inboundSchema.and(z.object({ type: z.literal("input_file") }).transform((v) => ({
-        type: v.type,
-    }))),
+    ResponseInputText$inboundSchema.and(z.object({ type: z.literal("input_text") })),
+    ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") })),
+    ResponseInputAudio$inboundSchema.and(z.object({ type: z.literal("input_audio") })),
+    ResponseInputFile$inboundSchema.and(z.object({ type: z.literal("input_file") })),
 ]);
 export function openAIResponsesInputContent3FromJSON(jsonString) {
     return safeParse(jsonString, (x) => OpenAIResponsesInputContent3$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenAIResponsesInputContent3' from JSON`);
@@ -124,18 +116,10 @@ export const OpenAIResponsesInputMessage2$inboundSchema = z.object({
         OpenAIResponsesInputRoleDeveloper2$inboundSchema,
     ]),
     content: z.array(z.union([
-        ResponseInputText$inboundSchema.and(z.object({ type: z.literal("input_text") }).transform((v) => ({
-            type: v.type,
-        }))),
-        ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") }).transform((v) => ({
-            type: v.type,
-        }))),
-        ResponseInputAudio$inboundSchema.and(z.object({ type: z.literal("input_audio") }).transform((v) => ({
-            type: v.type,
-        }))),
-        ResponseInputFile$inboundSchema.and(z.object({ type: z.literal("input_file") }).transform((v) => ({
-            type: v.type,
-        }))),
+        ResponseInputText$inboundSchema.and(z.object({ type: z.literal("input_text") })),
+        ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") })),
+        ResponseInputAudio$inboundSchema.and(z.object({ type: z.literal("input_audio") })),
+        ResponseInputFile$inboundSchema.and(z.object({ type: z.literal("input_file") })),
     ])),
 });
 export function openAIResponsesInputMessage2FromJSON(jsonString) {
@@ -163,18 +147,10 @@ export function openAIResponsesInputRoleUnion1FromJSON(jsonString) {
 }
 /** @internal */
 export const OpenAIResponsesInputContent1$inboundSchema = z.union([
-    ResponseInputText$inboundSchema.and(z.object({ type: z.literal("input_text") }).transform((v) => ({
-        type: v.type,
-    }))),
-    ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") }).transform((v) => ({
-        type: v.type,
-    }))),
-    ResponseInputAudio$inboundSchema.and(z.object({ type: z.literal("input_audio") }).transform((v) => ({
-        type: v.type,
-    }))),
-    ResponseInputFile$inboundSchema.and(z.object({ type: z.literal("input_file") }).transform((v) => ({
-        type: v.type,
-    }))),
+    ResponseInputText$inboundSchema.and(z.object({ type: z.literal("input_text") })),
+    ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") })),
+    ResponseInputAudio$inboundSchema.and(z.object({ type: z.literal("input_audio") })),
+    ResponseInputFile$inboundSchema.and(z.object({ type: z.literal("input_file") })),
 ]);
 export function openAIResponsesInputContent1FromJSON(jsonString) {
     return safeParse(jsonString, (x) => OpenAIResponsesInputContent1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenAIResponsesInputContent1' from JSON`);
@@ -182,18 +158,10 @@ export function openAIResponsesInputContent1FromJSON(jsonString) {
 /** @internal */
 export const OpenAIResponsesInputContent2$inboundSchema = z.union([
     z.array(z.union([
-        ResponseInputText$inboundSchema.and(z.object({ type: z.literal("input_text") }).transform((v) => ({
-            type: v.type,
-        }))),
-        ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") }).transform((v) => ({
-            type: v.type,
-        }))),
-        ResponseInputAudio$inboundSchema.and(z.object({ type: z.literal("input_audio") }).transform((v) => ({
-            type: v.type,
-        }))),
-        ResponseInputFile$inboundSchema.and(z.object({ type: z.literal("input_file") }).transform((v) => ({
-            type: v.type,
-        }))),
+        ResponseInputText$inboundSchema.and(z.object({ type: z.literal("input_text") })),
+        ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") })),
+        ResponseInputAudio$inboundSchema.and(z.object({ type: z.literal("input_audio") })),
+        ResponseInputFile$inboundSchema.and(z.object({ type: z.literal("input_file") })),
     ])),
     z.string(),
 ]);
@@ -211,18 +179,10 @@ export const OpenAIResponsesInputMessage1$inboundSchema = z.object({
     ]),
     content: z.union([
         z.array(z.union([
-            ResponseInputText$inboundSchema.and(z.object({ type: z.literal("input_text") }).transform((v) => ({
-                type: v.type,
-            }))),
-            ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") }).transform((v) => ({
-                type: v.type,
-            }))),
-            ResponseInputAudio$inboundSchema.and(z.object({ type: z.literal("input_audio") }).transform((v) => ({
-                type: v.type,
-            }))),
-            ResponseInputFile$inboundSchema.and(z.object({ type: z.literal("input_file") }).transform((v) => ({
-                type: v.type,
-            }))),
+            ResponseInputText$inboundSchema.and(z.object({ type: z.literal("input_text") })),
+            ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") })),
+            ResponseInputAudio$inboundSchema.and(z.object({ type: z.literal("input_audio") })),
+            ResponseInputFile$inboundSchema.and(z.object({ type: z.literal("input_file") })),
         ])),
         z.string(),
     ]),
@@ -234,9 +194,9 @@ export function openAIResponsesInputMessage1FromJSON(jsonString) {
 export const OpenAIResponsesInputUnion1$inboundSchema = z.union([
     z.lazy(() => OpenAIResponsesInputFunctionCallOutput$inboundSchema),
     z.lazy(() => OpenAIResponsesInputFunctionCall$inboundSchema),
-    OutputItemImageGenerationCall$inboundSchema,
     OutputMessage$inboundSchema,
     z.lazy(() => OpenAIResponsesInputMessage2$inboundSchema),
+    OutputItemImageGenerationCall$inboundSchema,
     z.lazy(() => OpenAIResponsesInputMessage1$inboundSchema),
 ]);
 export function openAIResponsesInputUnion1FromJSON(jsonString) {
@@ -248,9 +208,9 @@ export const OpenAIResponsesInputUnion$inboundSchema = z.union([
     z.array(z.union([
         z.lazy(() => OpenAIResponsesInputFunctionCallOutput$inboundSchema),
         z.lazy(() => OpenAIResponsesInputFunctionCall$inboundSchema),
-        OutputItemImageGenerationCall$inboundSchema,
         OutputMessage$inboundSchema,
         z.lazy(() => OpenAIResponsesInputMessage2$inboundSchema),
+        OutputItemImageGenerationCall$inboundSchema,
         z.lazy(() => OpenAIResponsesInputMessage1$inboundSchema),
     ])),
     z.any(),

package/esm/models/openresponseseasyinputmessage.js

@@ -43,18 +43,10 @@ export function openResponsesEasyInputMessageRoleUnionToJSON(openResponsesEasyIn
 }
 /** @internal */
 export const OpenResponsesEasyInputMessageContent1$outboundSchema = z.union([
-    ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") }).transform((v) => ({
-        type: v.type,
-    }))),
-    ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") }).transform((v) => ({
-        type: v.type,
-    }))),
-    ResponseInputAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") }).transform((v) => ({
-        type: v.type,
-    }))),
-    ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") }).transform((v) => ({
-        type: v.type,
-    }))),
+    ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") })),
+    ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") })),
+    ResponseInputAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") })),
+    ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") })),
 ]);
 export function openResponsesEasyInputMessageContent1ToJSON(openResponsesEasyInputMessageContent1) {
     return JSON.stringify(OpenResponsesEasyInputMessageContent1$outboundSchema.parse(openResponsesEasyInputMessageContent1));
@@ -62,18 +54,10 @@ export function openResponsesEasyInputMessageContent1ToJSON(openResponsesEasyInp
 /** @internal */
 export const OpenResponsesEasyInputMessageContent2$outboundSchema = z.union([
     z.array(z.union([
-        ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") }).transform((v) => ({
-            type: v.type,
-        }))),
-        ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") }).transform((v) => ({
-            type: v.type,
-        }))),
-        ResponseInputAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") }).transform((v) => ({
-            type: v.type,
-        }))),
-        ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") }).transform((v) => ({
-            type: v.type,
-        }))),
+        ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") })),
+        ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") })),
+        ResponseInputAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") })),
+        ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") })),
     ])),
     z.string(),
 ]);
@@ -91,18 +75,10 @@ export const OpenResponsesEasyInputMessage$outboundSchema = z.object({
     ]),
     content: z.union([
         z.array(z.union([
-            ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") }).transform((v) => ({
-                type: v.type,
-            }))),
-            ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") }).transform((v) => ({
-                type: v.type,
-            }))),
-            ResponseInputAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") }).transform((v) => ({
-                type: v.type,
-            }))),
-            ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") }).transform((v) => ({
-                type: v.type,
-            }))),
+            ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") })),
+            ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") })),
+            ResponseInputAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") })),
+            ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") })),
         ])),
         z.string(),
     ]),

package/esm/models/openresponsesinput.d.ts

@@ -10,18 +10,18 @@ import { ResponsesOutputItemFunctionCall, ResponsesOutputItemFunctionCall$Outbou
 import { ResponsesOutputItemReasoning, ResponsesOutputItemReasoning$Outbound } from "./responsesoutputitemreasoning.js";
 import { ResponsesOutputMessage, ResponsesOutputMessage$Outbound } from "./responsesoutputmessage.js";
 import { ResponsesWebSearchCallOutput, ResponsesWebSearchCallOutput$Outbound } from "./responseswebsearchcalloutput.js";
-export type OpenResponsesInput1 = OpenResponsesFunctionToolCall | OpenResponsesFunctionCallOutput | ResponsesOutputMessage | ResponsesOutputItemFunctionCall | ResponsesOutputItemFileSearchCall | ResponsesImageGenerationCall | OpenResponsesReasoning | ResponsesWebSearchCallOutput | OpenResponsesEasyInputMessage | OpenResponsesInputMessageItem | ResponsesOutputItemReasoning;
+export type OpenResponsesInput1 = OpenResponsesFunctionToolCall | OpenResponsesFunctionCallOutput | ResponsesOutputMessage | ResponsesOutputItemFunctionCall | ResponsesOutputItemFileSearchCall | OpenResponsesReasoning | ResponsesWebSearchCallOutput | ResponsesImageGenerationCall | OpenResponsesEasyInputMessage | OpenResponsesInputMessageItem | ResponsesOutputItemReasoning;
 /**
  * Input for a response request - can be a string or array of items
  */
-export type OpenResponsesInput = string | Array<OpenResponsesFunctionToolCall | OpenResponsesFunctionCallOutput | ResponsesOutputMessage | ResponsesOutputItemFunctionCall | ResponsesOutputItemFileSearchCall | ResponsesImageGenerationCall | OpenResponsesReasoning | ResponsesWebSearchCallOutput | OpenResponsesEasyInputMessage | OpenResponsesInputMessageItem | ResponsesOutputItemReasoning>;
+export type OpenResponsesInput = string | Array<OpenResponsesFunctionToolCall | OpenResponsesFunctionCallOutput | ResponsesOutputMessage | ResponsesOutputItemFunctionCall | ResponsesOutputItemFileSearchCall | OpenResponsesReasoning | ResponsesWebSearchCallOutput | ResponsesImageGenerationCall | OpenResponsesEasyInputMessage | OpenResponsesInputMessageItem | ResponsesOutputItemReasoning>;
 /** @internal */
-export type OpenResponsesInput1$Outbound = OpenResponsesFunctionToolCall$Outbound | OpenResponsesFunctionCallOutput$Outbound | ResponsesOutputMessage$Outbound | ResponsesOutputItemFunctionCall$Outbound | ResponsesOutputItemFileSearchCall$Outbound | ResponsesImageGenerationCall$Outbound | OpenResponsesReasoning$Outbound | ResponsesWebSearchCallOutput$Outbound | OpenResponsesEasyInputMessage$Outbound | OpenResponsesInputMessageItem$Outbound | ResponsesOutputItemReasoning$Outbound;
+export type OpenResponsesInput1$Outbound = OpenResponsesFunctionToolCall$Outbound | OpenResponsesFunctionCallOutput$Outbound | ResponsesOutputMessage$Outbound | ResponsesOutputItemFunctionCall$Outbound | ResponsesOutputItemFileSearchCall$Outbound | OpenResponsesReasoning$Outbound | ResponsesWebSearchCallOutput$Outbound | ResponsesImageGenerationCall$Outbound | OpenResponsesEasyInputMessage$Outbound | OpenResponsesInputMessageItem$Outbound | ResponsesOutputItemReasoning$Outbound;
 /** @internal */
 export declare const OpenResponsesInput1$outboundSchema: z.ZodType<OpenResponsesInput1$Outbound, OpenResponsesInput1>;
 export declare function openResponsesInput1ToJSON(openResponsesInput1: OpenResponsesInput1): string;
 /** @internal */
-export type OpenResponsesInput$Outbound = string | Array<OpenResponsesFunctionToolCall$Outbound | OpenResponsesFunctionCallOutput$Outbound | ResponsesOutputMessage$Outbound | ResponsesOutputItemFunctionCall$Outbound | ResponsesOutputItemFileSearchCall$Outbound | ResponsesImageGenerationCall$Outbound | OpenResponsesReasoning$Outbound | ResponsesWebSearchCallOutput$Outbound | OpenResponsesEasyInputMessage$Outbound | OpenResponsesInputMessageItem$Outbound | ResponsesOutputItemReasoning$Outbound>;
+export type OpenResponsesInput$Outbound = string | Array<OpenResponsesFunctionToolCall$Outbound | OpenResponsesFunctionCallOutput$Outbound | ResponsesOutputMessage$Outbound | ResponsesOutputItemFunctionCall$Outbound | ResponsesOutputItemFileSearchCall$Outbound | OpenResponsesReasoning$Outbound | ResponsesWebSearchCallOutput$Outbound | ResponsesImageGenerationCall$Outbound | OpenResponsesEasyInputMessage$Outbound | OpenResponsesInputMessageItem$Outbound | ResponsesOutputItemReasoning$Outbound>;
 /** @internal */
 export declare const OpenResponsesInput$outboundSchema: z.ZodType<OpenResponsesInput$Outbound, OpenResponsesInput>;
 export declare function openResponsesInputToJSON(openResponsesInput: OpenResponsesInput): string;

package/esm/models/openresponsesinput.js

@@ -20,9 +20,9 @@ export const OpenResponsesInput1$outboundSchema = z.union([
     ResponsesOutputMessage$outboundSchema,
     ResponsesOutputItemFunctionCall$outboundSchema,
     ResponsesOutputItemFileSearchCall$outboundSchema,
-    ResponsesImageGenerationCall$outboundSchema,
     OpenResponsesReasoning$outboundSchema,
     ResponsesWebSearchCallOutput$outboundSchema,
+    ResponsesImageGenerationCall$outboundSchema,
     OpenResponsesEasyInputMessage$outboundSchema,
     OpenResponsesInputMessageItem$outboundSchema,
     ResponsesOutputItemReasoning$outboundSchema,
@@ -39,9 +39,9 @@ export const OpenResponsesInput$outboundSchema = z.union([
         ResponsesOutputMessage$outboundSchema,
         ResponsesOutputItemFunctionCall$outboundSchema,
         ResponsesOutputItemFileSearchCall$outboundSchema,
-        ResponsesImageGenerationCall$outboundSchema,
         OpenResponsesReasoning$outboundSchema,
         ResponsesWebSearchCallOutput$outboundSchema,
+        ResponsesImageGenerationCall$outboundSchema,
         OpenResponsesEasyInputMessage$outboundSchema,
         OpenResponsesInputMessageItem$outboundSchema,
         ResponsesOutputItemReasoning$outboundSchema,

package/esm/models/openresponsesinputmessageitem.js

@@ -37,18 +37,10 @@ export function openResponsesInputMessageItemRoleUnionToJSON(openResponsesInputM
 }
 /** @internal */
 export const OpenResponsesInputMessageItemContent$outboundSchema = z.union([
-    ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") }).transform((v) => ({
-        type: v.type,
-    }))),
-    ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") }).transform((v) => ({
-        type: v.type,
-    }))),
-    ResponseInputAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") }).transform((v) => ({
-        type: v.type,
-    }))),
-    ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") }).transform((v) => ({
-        type: v.type,
-    }))),
+    ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") })),
+    ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") })),
+    ResponseInputAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") })),
+    ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") })),
 ]);
 export function openResponsesInputMessageItemContentToJSON(openResponsesInputMessageItemContent) {
     return JSON.stringify(OpenResponsesInputMessageItemContent$outboundSchema.parse(openResponsesInputMessageItemContent));
@@ -63,18 +55,10 @@ export const OpenResponsesInputMessageItem$outboundSchema = z.object({
         OpenResponsesInputMessageItemRoleDeveloper$outboundSchema,
     ]),
     content: z.array(z.union([
-        ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") }).transform((v) => ({
-            type: v.type,
-        }))),
-        ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") }).transform((v) => ({
-            type: v.type,
-        }))),
-        ResponseInputAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") }).transform((v) => ({
-            type: v.type,
-        }))),
-        ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") }).transform((v) => ({
-            type: v.type,
-        }))),
+        ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") })),
+        ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") })),
+        ResponseInputAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") })),
+        ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") })),
     ])),
 });
 export function openResponsesInputMessageItemToJSON(openResponsesInputMessageItem) {

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

@@ -30,6 +30,10 @@ export type CreateAuthKeysCodeRequest = {
      * Credit limit for the API key to be created
      */
     limit?: number | undefined;
+    /**
+     * Optional expiration time for the API key to be created
+     */
+    expiresAt?: Date | null | undefined;
 };
 /**
  * Auth code data
@@ -65,6 +69,7 @@ export type CreateAuthKeysCodeRequest$Outbound = {
     code_challenge?: string | undefined;
     code_challenge_method?: string | undefined;
     limit?: number | undefined;
+    expires_at?: string | null | undefined;
 };
 /** @internal */
 export declare const CreateAuthKeysCodeRequest$outboundSchema: z.ZodType<CreateAuthKeysCodeRequest$Outbound, CreateAuthKeysCodeRequest>;

package/esm/models/operations/createauthkeyscode.js

@@ -23,11 +23,13 @@ export const CreateAuthKeysCodeRequest$outboundSchema = z.object({
     codeChallengeMethod: CreateAuthKeysCodeCodeChallengeMethod$outboundSchema
         .optional(),
     limit: z.number().optional(),
+    expiresAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
 }).transform((v) => {
     return remap$(v, {
         callbackUrl: "callback_url",
         codeChallenge: "code_challenge",
         codeChallengeMethod: "code_challenge_method",
+        expiresAt: "expires_at",
     });
 });
 export function createAuthKeysCodeRequestToJSON(createAuthKeysCodeRequest) {

package/esm/models/outputitemimagegenerationcall.d.ts

@@ -10,7 +10,7 @@ export type OutputItemImageGenerationCallType = ClosedEnum<typeof OutputItemImag
 export type OutputItemImageGenerationCall = {
     type: OutputItemImageGenerationCallType;
     id: string;
-    result: string | null;
+    result?: string | null | undefined;
     status: ImageGenerationStatus;
 };
 /** @internal */

package/esm/models/outputitemimagegenerationcall.js

@@ -13,7 +13,7 @@ export const OutputItemImageGenerationCallType$inboundSchema = z.enum(OutputItem
 export const OutputItemImageGenerationCall$inboundSchema = z.object({
     type: OutputItemImageGenerationCallType$inboundSchema,
     id: z.string(),
-    result: z.nullable(z.string()),
+    result: z.nullable(z.string()).default(null),
     status: ImageGenerationStatus$inboundSchema,
 });
 export function outputItemImageGenerationCallFromJSON(jsonString) {

package/esm/models/payloadtoolargeresponseerrordata.js

@@ -5,7 +5,7 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const PayloadTooLargeResponseErrorData$inboundSchema = z.object({
-    code: z.number().int(),
+    code: z.int(),
     message: z.string(),
     metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
 });

package/esm/models/paymentrequiredresponseerrordata.js

@@ -5,7 +5,7 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const PaymentRequiredResponseErrorData$inboundSchema = z.object({
-    code: z.number().int(),
+    code: z.int(),
     message: z.string(),
     metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
 });

package/esm/models/provideroverloadedresponseerrordata.js

@@ -5,7 +5,7 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const ProviderOverloadedResponseErrorData$inboundSchema = z.object({
-    code: z.number().int(),
+    code: z.int(),
     message: z.string(),
     metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
 });

package/esm/models/requesttimeoutresponseerrordata.js

@@ -5,7 +5,7 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const RequestTimeoutResponseErrorData$inboundSchema = z.object({
-    code: z.number().int(),
+    code: z.int(),
     message: z.string(),
     metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
 });

package/esm/models/responsesimagegenerationcall.d.ts

@@ -10,7 +10,7 @@ export type ResponsesImageGenerationCallType = ClosedEnum<typeof ResponsesImageG
 export type ResponsesImageGenerationCall = {
     type: ResponsesImageGenerationCallType;
     id: string;
-    result: string | null;
+    result?: string | null | undefined;
     status: ImageGenerationStatus;
 };
 /** @internal */

package/esm/models/responsesimagegenerationcall.js

@@ -15,14 +15,14 @@ export const ResponsesImageGenerationCallType$outboundSchema = ResponsesImageGen
 export const ResponsesImageGenerationCall$inboundSchema = z.object({
     type: ResponsesImageGenerationCallType$inboundSchema,
     id: z.string(),
-    result: z.nullable(z.string()),
+    result: z.nullable(z.string()).default(null),
     status: ImageGenerationStatus$inboundSchema,
 });
 /** @internal */
 export const ResponsesImageGenerationCall$outboundSchema = z.object({
     type: ResponsesImageGenerationCallType$outboundSchema,
     id: z.string(),
-    result: z.nullable(z.string()),
+    result: z.nullable(z.string()).default(null),
     status: ImageGenerationStatus$outboundSchema,
 });
 export function responsesImageGenerationCallToJSON(responsesImageGenerationCall) {

package/esm/models/responsesoutputitem.d.ts

@@ -10,7 +10,7 @@ import { ResponsesWebSearchCallOutput } from "./responseswebsearchcalloutput.js"
 /**
  * An output item from the response
  */
-export type ResponsesOutputItem = ResponsesOutputMessage | ResponsesOutputItemFunctionCall | ResponsesOutputItemFileSearchCall | ResponsesImageGenerationCall | ResponsesWebSearchCallOutput | ResponsesOutputItemReasoning;
+export type ResponsesOutputItem = ResponsesOutputMessage | ResponsesOutputItemFunctionCall | ResponsesOutputItemFileSearchCall | ResponsesWebSearchCallOutput | ResponsesImageGenerationCall | ResponsesOutputItemReasoning;
 /** @internal */
 export declare const ResponsesOutputItem$inboundSchema: z.ZodType<ResponsesOutputItem, unknown>;
 export declare function responsesOutputItemFromJSON(jsonString: string): SafeParseResult<ResponsesOutputItem, SDKValidationError>;

package/esm/models/responsesoutputitem.js

@@ -14,8 +14,8 @@ export const ResponsesOutputItem$inboundSchema = z.union([
     ResponsesOutputMessage$inboundSchema,
     ResponsesOutputItemFunctionCall$inboundSchema,
     ResponsesOutputItemFileSearchCall$inboundSchema,
-    ResponsesImageGenerationCall$inboundSchema,
     ResponsesWebSearchCallOutput$inboundSchema,
+    ResponsesImageGenerationCall$inboundSchema,
     ResponsesOutputItemReasoning$inboundSchema,
 ]);
 export function responsesOutputItemFromJSON(jsonString) {

package/esm/models/serviceunavailableresponseerrordata.js

@@ -5,7 +5,7 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const ServiceUnavailableResponseErrorData$inboundSchema = z.object({
-    code: z.number().int(),
+    code: z.int(),
     message: z.string(),
     metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
 });

package/esm/models/toomanyrequestsresponseerrordata.js

@@ -5,7 +5,7 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const TooManyRequestsResponseErrorData$inboundSchema = z.object({
-    code: z.number().int(),
+    code: z.int(),
     message: z.string(),
     metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
 });

package/esm/models/unauthorizedresponseerrordata.js

@@ -5,7 +5,7 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const UnauthorizedResponseErrorData$inboundSchema = z.object({
-    code: z.number().int(),
+    code: z.int(),
     message: z.string(),
     metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
 });

package/esm/models/unprocessableentityresponseerrordata.js

@@ -5,7 +5,7 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const UnprocessableEntityResponseErrorData$inboundSchema = z.object({
-    code: z.number().int(),
+    code: z.int(),
     message: z.string(),
     metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
 });

package/esm/react-query/embeddingsListModels.d.ts

@@ -0,0 +1,29 @@
+import { InvalidateQueryFilters, QueryClient, QueryFunctionContext, QueryKey, UseQueryResult, UseSuspenseQueryResult } from "@tanstack/react-query";
+import { OpenRouterCore } from "../core.js";
+import { RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import { QueryHookOptions, SuspenseQueryHookOptions } from "./_types.js";
+export type EmbeddingsListModelsQueryData = models.ModelsListResponse;
+/**
+ * List all embeddings models
+ *
+ * @remarks
+ * Returns a list of all available embeddings models and their properties
+ */
+export declare function useEmbeddingsListModels(options?: QueryHookOptions<EmbeddingsListModelsQueryData>): UseQueryResult<EmbeddingsListModelsQueryData, Error>;
+/**
+ * List all embeddings models
+ *
+ * @remarks
+ * Returns a list of all available embeddings models and their properties
+ */
+export declare function useEmbeddingsListModelsSuspense(options?: SuspenseQueryHookOptions<EmbeddingsListModelsQueryData>): UseSuspenseQueryResult<EmbeddingsListModelsQueryData, Error>;
+export declare function prefetchEmbeddingsListModels(queryClient: QueryClient, client$: OpenRouterCore): Promise<void>;
+export declare function setEmbeddingsListModelsData(client: QueryClient, data: EmbeddingsListModelsQueryData): EmbeddingsListModelsQueryData | undefined;
+export declare function invalidateAllEmbeddingsListModels(client: QueryClient, filters?: Omit<InvalidateQueryFilters, "queryKey" | "predicate" | "exact">): Promise<void>;
+export declare function buildEmbeddingsListModelsQuery(client$: OpenRouterCore, options?: RequestOptions): {
+    queryKey: QueryKey;
+    queryFn: (context: QueryFunctionContext) => Promise<EmbeddingsListModelsQueryData>;
+};
+export declare function queryKeyEmbeddingsListModels(): QueryKey;
+//# sourceMappingURL=embeddingsListModels.d.ts.map

package/esm/react-query/{modelsListEmbeddings.js → embeddingsListModels.js}

@@ -2,7 +2,7 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 import { useQuery, useSuspenseQuery, } from "@tanstack/react-query";
-import { modelsListEmbeddings } from "../funcs/modelsListEmbeddings.js";
+import { embeddingsListModels } from "../funcs/embeddingsListModels.js";
 import { combineSignals } from "../lib/primitives.js";
 import { unwrapAsync } from "../types/fp.js";
 import { useOpenRouterContext } from "./_context.js";
@@ -12,10 +12,10 @@ import { useOpenRouterContext } from "./_context.js";
  * @remarks
  * Returns a list of all available embeddings models and their properties
  */
-export function useModelsListEmbeddings(options) {
+export function useEmbeddingsListModels(options) {
     const client = useOpenRouterContext();
     return useQuery({
-        ...buildModelsListEmbeddingsQuery(client, options),
+        ...buildEmbeddingsListModelsQuery(client, options),
         ...options,
     });
 }
@@ -25,42 +25,42 @@ export function useModelsListEmbeddings(options) {
  * @remarks
  * Returns a list of all available embeddings models and their properties
  */
-export function useModelsListEmbeddingsSuspense(options) {
+export function useEmbeddingsListModelsSuspense(options) {
     const client = useOpenRouterContext();
     return useSuspenseQuery({
-        ...buildModelsListEmbeddingsQuery(client, options),
+        ...buildEmbeddingsListModelsQuery(client, options),
         ...options,
     });
 }
-export function prefetchModelsListEmbeddings(queryClient, client$) {
+export function prefetchEmbeddingsListModels(queryClient, client$) {
     return queryClient.prefetchQuery({
-        ...buildModelsListEmbeddingsQuery(client$),
+        ...buildEmbeddingsListModelsQuery(client$),
     });
 }
-export function setModelsListEmbeddingsData(client, data) {
-    const key = queryKeyModelsListEmbeddings();
+export function setEmbeddingsListModelsData(client, data) {
+    const key = queryKeyEmbeddingsListModels();
     return client.setQueryData(key, data);
 }
-export function invalidateAllModelsListEmbeddings(client, filters) {
+export function invalidateAllEmbeddingsListModels(client, filters) {
     return client.invalidateQueries({
         ...filters,
-        queryKey: ["@openrouter/sdk", "Models", "listEmbeddings"],
+        queryKey: ["@openrouter/sdk", "Embeddings", "listModels"],
     });
 }
-export function buildModelsListEmbeddingsQuery(client$, options) {
+export function buildEmbeddingsListModelsQuery(client$, options) {
     return {
-        queryKey: queryKeyModelsListEmbeddings(),
-        queryFn: async function modelsListEmbeddingsQueryFn(ctx) {
+        queryKey: queryKeyEmbeddingsListModels(),
+        queryFn: async function embeddingsListModelsQueryFn(ctx) {
             const sig = combineSignals(ctx.signal, options?.fetchOptions?.signal);
             const mergedOptions = {
                 ...options,
                 fetchOptions: { ...options?.fetchOptions, signal: sig },
             };
-            return unwrapAsync(modelsListEmbeddings(client$, mergedOptions));
+            return unwrapAsync(embeddingsListModels(client$, mergedOptions));
         },
     };
 }
-export function queryKeyModelsListEmbeddings() {
-    return ["@openrouter/sdk", "Models", "listEmbeddings"];
+export function queryKeyEmbeddingsListModels() {
+    return ["@openrouter/sdk", "Embeddings", "listModels"];
 }
-//# sourceMappingURL=modelsListEmbeddings.js.map
+//# sourceMappingURL=embeddingsListModels.js.map

package/esm/react-query/index.d.ts

@@ -13,12 +13,12 @@ export * from "./completionsGenerate.js";
 export * from "./creditsCreateCoinbaseCharge.js";
 export * from "./creditsGetCredits.js";
 export * from "./embeddingsGenerate.js";
+export * from "./embeddingsListModels.js";
 export * from "./endpointsList.js";
 export * from "./endpointsListZdrEndpoints.js";
 export * from "./generationsGetGeneration.js";
 export * from "./modelsCount.js";
 export * from "./modelsList.js";
-export * from "./modelsListEmbeddings.js";
 export * from "./modelsListForUser.js";
 export * from "./oAuthCreateAuthCode.js";
 export * from "./oAuthExchangeAuthCodeForAPIKey.js";

package/esm/react-query/index.js

@@ -16,12 +16,12 @@ export * from "./completionsGenerate.js";
 export * from "./creditsCreateCoinbaseCharge.js";
 export * from "./creditsGetCredits.js";
 export * from "./embeddingsGenerate.js";
+export * from "./embeddingsListModels.js";
 export * from "./endpointsList.js";
 export * from "./endpointsListZdrEndpoints.js";
 export * from "./generationsGetGeneration.js";
 export * from "./modelsCount.js";
 export * from "./modelsList.js";
-export * from "./modelsListEmbeddings.js";
 export * from "./modelsListForUser.js";
 export * from "./oAuthCreateAuthCode.js";
 export * from "./oAuthExchangeAuthCodeForAPIKey.js";

package/esm/sdk/embeddings.d.ts

@@ -1,4 +1,5 @@
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 export declare class Embeddings extends ClientSDK {
     /**
@@ -8,5 +9,12 @@ export declare class Embeddings extends ClientSDK {
      * Submits an embedding request to the embeddings router
      */
     generate(request: operations.CreateEmbeddingsRequest, options?: RequestOptions): Promise<operations.CreateEmbeddingsResponse>;
+    /**
+     * List all embeddings models
+     *
+     * @remarks
+     * Returns a list of all available embeddings models and their properties
+     */
+    listModels(options?: RequestOptions): Promise<models.ModelsListResponse>;
 }
 //# sourceMappingURL=embeddings.d.ts.map

package/esm/sdk/embeddings.js

@@ -2,6 +2,7 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 import { embeddingsGenerate } from "../funcs/embeddingsGenerate.js";
+import { embeddingsListModels } from "../funcs/embeddingsListModels.js";
 import { ClientSDK } from "../lib/sdks.js";
 import { unwrapAsync } from "../types/fp.js";
 export class Embeddings extends ClientSDK {
@@ -14,5 +15,14 @@ export class Embeddings extends ClientSDK {
     async generate(request, options) {
         return unwrapAsync(embeddingsGenerate(this, request, options));
     }
+    /**
+     * List all embeddings models
+     *
+     * @remarks
+     * Returns a list of all available embeddings models and their properties
+     */
+    async listModels(options) {
+        return unwrapAsync(embeddingsListModels(this, options));
+    }
 }
 //# sourceMappingURL=embeddings.js.map

package/esm/sdk/models.d.ts

@@ -10,13 +10,6 @@ export declare class Models extends ClientSDK {
      * List all models and their properties
      */
     list(request?: operations.GetModelsRequest | undefined, options?: RequestOptions): Promise<models.ModelsListResponse>;
-    /**
-     * List all embeddings models
-     *
-     * @remarks
-     * Returns a list of all available embeddings models and their properties
-     */
-    listEmbeddings(options?: RequestOptions): Promise<models.ModelsListResponse>;
     /**
      * List models filtered by user provider preferences
      */

package/esm/sdk/models.js

@@ -3,7 +3,6 @@
  */
 import { modelsCount } from "../funcs/modelsCount.js";
 import { modelsList } from "../funcs/modelsList.js";
-import { modelsListEmbeddings } from "../funcs/modelsListEmbeddings.js";
 import { modelsListForUser } from "../funcs/modelsListForUser.js";
 import { ClientSDK } from "../lib/sdks.js";
 import { unwrapAsync } from "../types/fp.js";
@@ -20,15 +19,6 @@ export class Models extends ClientSDK {
     async list(request, options) {
         return unwrapAsync(modelsList(this, request, options));
     }
-    /**
-     * List all embeddings models
-     *
-     * @remarks
-     * Returns a list of all available embeddings models and their properties
-     */
-    async listEmbeddings(options) {
-        return unwrapAsync(modelsListEmbeddings(this, options));
-    }
     /**
      * List models filtered by user provider preferences
      */

package/jsr.json

@@ -2,7 +2,7 @@
 
 {
   "name": "@openrouter/sdk",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "exports": {
     ".": "./src/index.ts",    
     "./models/errors": "./src/models/errors/index.ts",    

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "author": "OpenRouter",
   "description": "The OpenRouter TypeScript SDK is a type-safe toolkit for building AI applications with access to 300+ language models through a unified API.",
   "keywords": [

package/esm/react-query/modelsListEmbeddings.d.ts

@@ -1,29 +0,0 @@
-import { InvalidateQueryFilters, QueryClient, QueryFunctionContext, QueryKey, UseQueryResult, UseSuspenseQueryResult } from "@tanstack/react-query";
-import { OpenRouterCore } from "../core.js";
-import { RequestOptions } from "../lib/sdks.js";
-import * as models from "../models/index.js";
-import { QueryHookOptions, SuspenseQueryHookOptions } from "./_types.js";
-export type ModelsListEmbeddingsQueryData = models.ModelsListResponse;
-/**
- * List all embeddings models
- *
- * @remarks
- * Returns a list of all available embeddings models and their properties
- */
-export declare function useModelsListEmbeddings(options?: QueryHookOptions<ModelsListEmbeddingsQueryData>): UseQueryResult<ModelsListEmbeddingsQueryData, Error>;
-/**
- * List all embeddings models
- *
- * @remarks
- * Returns a list of all available embeddings models and their properties
- */
-export declare function useModelsListEmbeddingsSuspense(options?: SuspenseQueryHookOptions<ModelsListEmbeddingsQueryData>): UseSuspenseQueryResult<ModelsListEmbeddingsQueryData, Error>;
-export declare function prefetchModelsListEmbeddings(queryClient: QueryClient, client$: OpenRouterCore): Promise<void>;
-export declare function setModelsListEmbeddingsData(client: QueryClient, data: ModelsListEmbeddingsQueryData): ModelsListEmbeddingsQueryData | undefined;
-export declare function invalidateAllModelsListEmbeddings(client: QueryClient, filters?: Omit<InvalidateQueryFilters, "queryKey" | "predicate" | "exact">): Promise<void>;
-export declare function buildModelsListEmbeddingsQuery(client$: OpenRouterCore, options?: RequestOptions): {
-    queryKey: QueryKey;
-    queryFn: (context: QueryFunctionContext) => Promise<ModelsListEmbeddingsQueryData>;
-};
-export declare function queryKeyModelsListEmbeddings(): QueryKey;
-//# sourceMappingURL=modelsListEmbeddings.d.ts.map