@openrouter/sdk 0.11.2 → 0.12.1

package/esm/models/chatcontentitems.js

@@ -4,6 +4,7 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
 import { ChatContentAudio$inboundSchema, ChatContentAudio$outboundSchema, } from "./chatcontentaudio.js";
 import { ChatContentFile$inboundSchema, ChatContentFile$outboundSchema, } from "./chatcontentfile.js";
 import { ChatContentImage$inboundSchema, ChatContentImage$outboundSchema, } from "./chatcontentimage.js";
@@ -11,42 +12,22 @@ import { ChatContentText$inboundSchema, ChatContentText$outboundSchema, } from "
 import { ChatContentVideo$inboundSchema, ChatContentVideo$outboundSchema, } from "./chatcontentvideo.js";
 import { LegacyChatContentVideo$inboundSchema, LegacyChatContentVideo$outboundSchema, } from "./legacychatcontentvideo.js";
 /** @internal */
-export const ChatContentItems1$inboundSchema = z.union([
-    LegacyChatContentVideo$inboundSchema,
-    ChatContentVideo$inboundSchema,
-]);
-/** @internal */
-export const ChatContentItems1$outboundSchema = z.union([
-    LegacyChatContentVideo$outboundSchema,
-    ChatContentVideo$outboundSchema,
-]);
-export function chatContentItems1ToJSON(chatContentItems1) {
-    return JSON.stringify(ChatContentItems1$outboundSchema.parse(chatContentItems1));
-}
-export function chatContentItems1FromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ChatContentItems1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatContentItems1' from JSON`);
-}
-/** @internal */
-export const ChatContentItems$inboundSchema = z.union([
-    ChatContentText$inboundSchema,
-    ChatContentImage$inboundSchema,
-    ChatContentAudio$inboundSchema,
-    ChatContentFile$inboundSchema,
-    z.union([
-        LegacyChatContentVideo$inboundSchema,
-        ChatContentVideo$inboundSchema,
-    ]),
-]);
+export const ChatContentItems$inboundSchema = discriminatedUnion("type", {
+    file: ChatContentFile$inboundSchema,
+    image_url: ChatContentImage$inboundSchema,
+    input_audio: ChatContentAudio$inboundSchema,
+    input_video: LegacyChatContentVideo$inboundSchema,
+    text: ChatContentText$inboundSchema.and(z.object({ type: z.literal("text") })),
+    video_url: ChatContentVideo$inboundSchema,
+});
 /** @internal */
 export const ChatContentItems$outboundSchema = z.union([
-    ChatContentText$outboundSchema,
+    ChatContentFile$outboundSchema,
     ChatContentImage$outboundSchema,
     ChatContentAudio$outboundSchema,
-    ChatContentFile$outboundSchema,
-    z.union([
-        LegacyChatContentVideo$outboundSchema,
-        ChatContentVideo$outboundSchema,
-    ]),
+    LegacyChatContentVideo$outboundSchema,
+    ChatContentText$outboundSchema.and(z.object({ type: z.literal("text") })),
+    ChatContentVideo$outboundSchema,
 ]);
 export function chatContentItemsToJSON(chatContentItems) {
     return JSON.stringify(ChatContentItems$outboundSchema.parse(chatContentItems));

package/esm/models/chatcontenttext.d.ts

@@ -11,12 +11,12 @@ export type ChatContentTextType = ClosedEnum<typeof ChatContentTextType>;
  * Text content part
  */
 export type ChatContentText = {
-    type: ChatContentTextType;
-    text: string;
     /**
      * Cache control for the content part
      */
     cacheControl?: ChatContentCacheControl | undefined;
+    text: string;
+    type: ChatContentTextType;
 };
 /** @internal */
 export declare const ChatContentTextType$inboundSchema: z.ZodEnum<typeof ChatContentTextType>;
@@ -26,9 +26,9 @@ export declare const ChatContentTextType$outboundSchema: z.ZodEnum<typeof ChatCo
 export declare const ChatContentText$inboundSchema: z.ZodType<ChatContentText, unknown>;
 /** @internal */
 export type ChatContentText$Outbound = {
-    type: string;
-    text: string;
     cache_control?: ChatContentCacheControl$Outbound | undefined;
+    text: string;
+    type: string;
 };
 /** @internal */
 export declare const ChatContentText$outboundSchema: z.ZodType<ChatContentText$Outbound, ChatContentText>;

package/esm/models/chatcontenttext.js

@@ -15,9 +15,9 @@ export const ChatContentTextType$inboundSchema = z.enum(ChatContentTextType);
 export const ChatContentTextType$outboundSchema = ChatContentTextType$inboundSchema;
 /** @internal */
 export const ChatContentText$inboundSchema = z.object({
-    type: ChatContentTextType$inboundSchema,
-    text: z.string(),
     cache_control: ChatContentCacheControl$inboundSchema.optional(),
+    text: z.string(),
+    type: ChatContentTextType$inboundSchema,
 }).transform((v) => {
     return remap$(v, {
         "cache_control": "cacheControl",
@@ -25,9 +25,9 @@ export const ChatContentText$inboundSchema = z.object({
 });
 /** @internal */
 export const ChatContentText$outboundSchema = z.object({
-    type: ChatContentTextType$outboundSchema,
-    text: z.string(),
     cacheControl: ChatContentCacheControl$outboundSchema.optional(),
+    text: z.string(),
+    type: ChatContentTextType$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         cacheControl: "cache_control",

package/esm/models/chatdevelopermessage.d.ts

@@ -8,7 +8,6 @@ export type ChatDeveloperMessageContent = string | Array<ChatContentText>;
  * Developer message
  */
 export type ChatDeveloperMessage = {
-    role: "developer";
     /**
      * Developer message content
      */
@@ -17,6 +16,7 @@ export type ChatDeveloperMessage = {
      * Optional name for the developer message
      */
     name?: string | undefined;
+    role: "developer";
 };
 /** @internal */
 export type ChatDeveloperMessageContent$Outbound = string | Array<ChatContentText$Outbound>;
@@ -25,9 +25,9 @@ export declare const ChatDeveloperMessageContent$outboundSchema: z.ZodType<ChatD
 export declare function chatDeveloperMessageContentToJSON(chatDeveloperMessageContent: ChatDeveloperMessageContent): string;
 /** @internal */
 export type ChatDeveloperMessage$Outbound = {
-    role: "developer";
     content: string | Array<ChatContentText$Outbound>;
     name?: string | undefined;
+    role: "developer";
 };
 /** @internal */
 export declare const ChatDeveloperMessage$outboundSchema: z.ZodType<ChatDeveloperMessage$Outbound, ChatDeveloperMessage>;

package/esm/models/chatdevelopermessage.js

@@ -11,9 +11,9 @@ export function chatDeveloperMessageContentToJSON(chatDeveloperMessageContent) {
 }
 /** @internal */
 export const ChatDeveloperMessage$outboundSchema = z.object({
-    role: z.literal("developer"),
     content: z.union([z.string(), z.array(ChatContentText$outboundSchema)]),
     name: z.string().optional(),
+    role: z.literal("developer"),
 });
 export function chatDeveloperMessageToJSON(chatDeveloperMessage) {
     return JSON.stringify(ChatDeveloperMessage$outboundSchema.parse(chatDeveloperMessage));

package/esm/models/chatformatgrammarconfig.d.ts

@@ -3,16 +3,16 @@ import * as z from "zod/v4";
  * Custom grammar response format
  */
 export type ChatFormatGrammarConfig = {
-    type: "grammar";
     /**
      * Custom grammar for text generation
      */
     grammar: string;
+    type: "grammar";
 };
 /** @internal */
 export type ChatFormatGrammarConfig$Outbound = {
-    type: "grammar";
     grammar: string;
+    type: "grammar";
 };
 /** @internal */
 export declare const ChatFormatGrammarConfig$outboundSchema: z.ZodType<ChatFormatGrammarConfig$Outbound, ChatFormatGrammarConfig>;

package/esm/models/chatformatgrammarconfig.js

@@ -5,8 +5,8 @@
 import * as z from "zod/v4";
 /** @internal */
 export const ChatFormatGrammarConfig$outboundSchema = z.object({
-    type: z.literal("grammar"),
     grammar: z.string(),
+    type: z.literal("grammar"),
 });
 export function chatFormatGrammarConfigToJSON(chatFormatGrammarConfig) {
     return JSON.stringify(ChatFormatGrammarConfig$outboundSchema.parse(chatFormatGrammarConfig));

package/esm/models/chatformatjsonschemaconfig.d.ts

@@ -4,16 +4,16 @@ import { ChatJsonSchemaConfig, ChatJsonSchemaConfig$Outbound } from "./chatjsons
  * JSON Schema response format for structured outputs
  */
 export type ChatFormatJsonSchemaConfig = {
-    type: "json_schema";
     /**
      * JSON Schema configuration object
      */
     jsonSchema: ChatJsonSchemaConfig;
+    type: "json_schema";
 };
 /** @internal */
 export type ChatFormatJsonSchemaConfig$Outbound = {
-    type: "json_schema";
     json_schema: ChatJsonSchemaConfig$Outbound;
+    type: "json_schema";
 };
 /** @internal */
 export declare const ChatFormatJsonSchemaConfig$outboundSchema: z.ZodType<ChatFormatJsonSchemaConfig$Outbound, ChatFormatJsonSchemaConfig>;

package/esm/models/chatformatjsonschemaconfig.js

@@ -7,8 +7,8 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { ChatJsonSchemaConfig$outboundSchema, } from "./chatjsonschemaconfig.js";
 /** @internal */
 export const ChatFormatJsonSchemaConfig$outboundSchema = z.object({
-    type: z.literal("json_schema"),
     jsonSchema: ChatJsonSchemaConfig$outboundSchema,
+    type: z.literal("json_schema"),
 }).transform((v) => {
     return remap$(v, {
         jsonSchema: "json_schema",

package/esm/models/chatfunctiontool.d.ts

@@ -1,25 +1,21 @@
 import * as z from "zod/v4";
 import { ClosedEnum } from "../types/enums.js";
 import { ChatContentCacheControl, ChatContentCacheControl$Outbound } from "./chatcontentcachecontrol.js";
-import { ChatWebSearchServerTool, ChatWebSearchServerTool$Outbound } from "./chatwebsearchservertool.js";
 import { ChatWebSearchShorthand, ChatWebSearchShorthand$Outbound } from "./chatwebsearchshorthand.js";
 import { DatetimeServerTool, DatetimeServerTool$Outbound } from "./datetimeservertool.js";
-export declare const ChatFunctionToolType: {
-    readonly Function: "function";
-};
-export type ChatFunctionToolType = ClosedEnum<typeof ChatFunctionToolType>;
+import { OpenRouterWebSearchServerTool, OpenRouterWebSearchServerTool$Outbound } from "./openrouterwebsearchservertool.js";
 /**
  * Function definition for tool calling
  */
 export type ChatFunctionToolFunctionFunction = {
-    /**
-     * Function name (a-z, A-Z, 0-9, underscores, dashes, max 64 chars)
-     */
-    name: string;
     /**
      * Function description for the model
      */
     description?: string | undefined;
+    /**
+     * Function name (a-z, A-Z, 0-9, underscores, dashes, max 64 chars)
+     */
+    name: string;
     /**
      * Function parameters as JSON Schema object
      */
@@ -31,27 +27,29 @@ export type ChatFunctionToolFunctionFunction = {
      */
     strict?: boolean | null | undefined;
 };
+export declare const ChatFunctionToolType: {
+    readonly Function: "function";
+};
+export type ChatFunctionToolType = ClosedEnum<typeof ChatFunctionToolType>;
 export type ChatFunctionToolFunction = {
-    type: ChatFunctionToolType;
-    /**
-     * Function definition for tool calling
-     */
-    function: ChatFunctionToolFunctionFunction;
     /**
      * Cache control for the content part
      */
     cacheControl?: ChatContentCacheControl | undefined;
+    /**
+     * Function definition for tool calling
+     */
+    function: ChatFunctionToolFunctionFunction;
+    type: ChatFunctionToolType;
 };
 /**
  * Tool definition for function calling (regular function or OpenRouter built-in server tool)
  */
-export type ChatFunctionTool = ChatFunctionToolFunction | DatetimeServerTool | ChatWebSearchServerTool | ChatWebSearchShorthand;
-/** @internal */
-export declare const ChatFunctionToolType$outboundSchema: z.ZodEnum<typeof ChatFunctionToolType>;
+export type ChatFunctionTool = ChatFunctionToolFunction | DatetimeServerTool | OpenRouterWebSearchServerTool | ChatWebSearchShorthand;
 /** @internal */
 export type ChatFunctionToolFunctionFunction$Outbound = {
-    name: string;
     description?: string | undefined;
+    name: string;
     parameters?: {
         [k: string]: any | null;
     } | undefined;
@@ -61,16 +59,18 @@ export type ChatFunctionToolFunctionFunction$Outbound = {
 export declare const ChatFunctionToolFunctionFunction$outboundSchema: z.ZodType<ChatFunctionToolFunctionFunction$Outbound, ChatFunctionToolFunctionFunction>;
 export declare function chatFunctionToolFunctionFunctionToJSON(chatFunctionToolFunctionFunction: ChatFunctionToolFunctionFunction): string;
 /** @internal */
+export declare const ChatFunctionToolType$outboundSchema: z.ZodEnum<typeof ChatFunctionToolType>;
+/** @internal */
 export type ChatFunctionToolFunction$Outbound = {
-    type: string;
-    function: ChatFunctionToolFunctionFunction$Outbound;
     cache_control?: ChatContentCacheControl$Outbound | undefined;
+    function: ChatFunctionToolFunctionFunction$Outbound;
+    type: string;
 };
 /** @internal */
 export declare const ChatFunctionToolFunction$outboundSchema: z.ZodType<ChatFunctionToolFunction$Outbound, ChatFunctionToolFunction>;
 export declare function chatFunctionToolFunctionToJSON(chatFunctionToolFunction: ChatFunctionToolFunction): string;
 /** @internal */
-export type ChatFunctionTool$Outbound = ChatFunctionToolFunction$Outbound | DatetimeServerTool$Outbound | ChatWebSearchServerTool$Outbound | ChatWebSearchShorthand$Outbound;
+export type ChatFunctionTool$Outbound = ChatFunctionToolFunction$Outbound | DatetimeServerTool$Outbound | OpenRouterWebSearchServerTool$Outbound | ChatWebSearchShorthand$Outbound;
 /** @internal */
 export declare const ChatFunctionTool$outboundSchema: z.ZodType<ChatFunctionTool$Outbound, ChatFunctionTool>;
 export declare function chatFunctionToolToJSON(chatFunctionTool: ChatFunctionTool): string;

package/esm/models/chatfunctiontool.js

@@ -5,18 +5,16 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { ChatContentCacheControl$outboundSchema, } from "./chatcontentcachecontrol.js";
-import { ChatWebSearchServerTool$outboundSchema, } from "./chatwebsearchservertool.js";
 import { ChatWebSearchShorthand$outboundSchema, } from "./chatwebsearchshorthand.js";
 import { DatetimeServerTool$outboundSchema, } from "./datetimeservertool.js";
+import { OpenRouterWebSearchServerTool$outboundSchema, } from "./openrouterwebsearchservertool.js";
 export const ChatFunctionToolType = {
     Function: "function",
 };
 /** @internal */
-export const ChatFunctionToolType$outboundSchema = z.enum(ChatFunctionToolType);
-/** @internal */
 export const ChatFunctionToolFunctionFunction$outboundSchema = z.object({
-    name: z.string(),
     description: z.string().optional(),
+    name: z.string(),
     parameters: z.record(z.string(), z.nullable(z.any())).optional(),
     strict: z.nullable(z.boolean()).optional(),
 });
@@ -24,10 +22,12 @@ export function chatFunctionToolFunctionFunctionToJSON(chatFunctionToolFunctionF
     return JSON.stringify(ChatFunctionToolFunctionFunction$outboundSchema.parse(chatFunctionToolFunctionFunction));
 }
 /** @internal */
+export const ChatFunctionToolType$outboundSchema = z.enum(ChatFunctionToolType);
+/** @internal */
 export const ChatFunctionToolFunction$outboundSchema = z.object({
-    type: ChatFunctionToolType$outboundSchema,
-    function: z.lazy(() => ChatFunctionToolFunctionFunction$outboundSchema),
     cacheControl: ChatContentCacheControl$outboundSchema.optional(),
+    function: z.lazy(() => ChatFunctionToolFunctionFunction$outboundSchema),
+    type: ChatFunctionToolType$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         cacheControl: "cache_control",
@@ -40,7 +40,7 @@ export function chatFunctionToolFunctionToJSON(chatFunctionToolFunction) {
 export const ChatFunctionTool$outboundSchema = z.union([
     z.lazy(() => ChatFunctionToolFunction$outboundSchema),
     DatetimeServerTool$outboundSchema,
-    ChatWebSearchServerTool$outboundSchema,
+    OpenRouterWebSearchServerTool$outboundSchema,
     ChatWebSearchShorthand$outboundSchema,
 ]);
 export function chatFunctionToolToJSON(chatFunctionTool) {

package/esm/models/chatjsonschemaconfig.d.ts

@@ -3,14 +3,14 @@ import * as z from "zod/v4";
  * JSON Schema configuration object
  */
 export type ChatJsonSchemaConfig = {
-    /**
-     * Schema name (a-z, A-Z, 0-9, underscores, dashes, max 64 chars)
-     */
-    name: string;
     /**
      * Schema description for the model
      */
     description?: string | undefined;
+    /**
+     * Schema name (a-z, A-Z, 0-9, underscores, dashes, max 64 chars)
+     */
+    name: string;
     /**
      * JSON Schema object
      */
@@ -24,8 +24,8 @@ export type ChatJsonSchemaConfig = {
 };
 /** @internal */
 export type ChatJsonSchemaConfig$Outbound = {
-    name: string;
     description?: string | undefined;
+    name: string;
     schema?: {
         [k: string]: any | null;
     } | undefined;

package/esm/models/chatjsonschemaconfig.js

@@ -5,8 +5,8 @@
 import * as z from "zod/v4";
 /** @internal */
 export const ChatJsonSchemaConfig$outboundSchema = z.object({
-    name: z.string(),
     description: z.string().optional(),
+    name: z.string(),
     schema: z.record(z.string(), z.nullable(z.any())).optional(),
     strict: z.nullable(z.boolean()).optional(),
 });

package/esm/models/chatmessages.d.ts

@@ -7,13 +7,13 @@ import { ChatUserMessage, ChatUserMessage$Outbound } from "./chatusermessage.js"
 /**
  * Chat completion message with role-based discrimination
  */
-export type ChatMessages = ChatSystemMessage | ChatUserMessage | ChatDeveloperMessage | (ChatAssistantMessage & {
+export type ChatMessages = (ChatAssistantMessage & {
     role: "assistant";
-}) | ChatToolMessage;
+}) | ChatDeveloperMessage | ChatSystemMessage | ChatToolMessage | ChatUserMessage;
 /** @internal */
-export type ChatMessages$Outbound = ChatSystemMessage$Outbound | ChatUserMessage$Outbound | ChatDeveloperMessage$Outbound | (ChatAssistantMessage$Outbound & {
+export type ChatMessages$Outbound = (ChatAssistantMessage$Outbound & {
     role: "assistant";
-}) | ChatToolMessage$Outbound;
+}) | ChatDeveloperMessage$Outbound | ChatSystemMessage$Outbound | ChatToolMessage$Outbound | ChatUserMessage$Outbound;
 /** @internal */
 export declare const ChatMessages$outboundSchema: z.ZodType<ChatMessages$Outbound, ChatMessages>;
 export declare function chatMessagesToJSON(chatMessages: ChatMessages): string;

package/esm/models/chatmessages.js

@@ -10,11 +10,11 @@ import { ChatToolMessage$outboundSchema, } from "./chattoolmessage.js";
 import { ChatUserMessage$outboundSchema, } from "./chatusermessage.js";
 /** @internal */
 export const ChatMessages$outboundSchema = z.union([
-    ChatSystemMessage$outboundSchema,
-    ChatUserMessage$outboundSchema,
-    ChatDeveloperMessage$outboundSchema,
     ChatAssistantMessage$outboundSchema.and(z.object({ role: z.literal("assistant") })),
+    ChatDeveloperMessage$outboundSchema,
+    ChatSystemMessage$outboundSchema,
     ChatToolMessage$outboundSchema,
+    ChatUserMessage$outboundSchema,
 ]);
 export function chatMessagesToJSON(chatMessages) {
     return JSON.stringify(ChatMessages$outboundSchema.parse(chatMessages));

package/esm/models/chatnamedtoolchoice.d.ts

@@ -1,25 +1,23 @@
 import * as z from "zod/v4";
 import { ClosedEnum } from "../types/enums.js";
-export declare const ChatNamedToolChoiceType: {
-    readonly Function: "function";
-};
-export type ChatNamedToolChoiceType = ClosedEnum<typeof ChatNamedToolChoiceType>;
 export type ChatNamedToolChoiceFunction = {
     /**
      * Function name to call
      */
     name: string;
 };
+export declare const ChatNamedToolChoiceType: {
+    readonly Function: "function";
+};
+export type ChatNamedToolChoiceType = ClosedEnum<typeof ChatNamedToolChoiceType>;
 /**
  * Named tool choice for specific function
  */
 export type ChatNamedToolChoice = {
-    type: ChatNamedToolChoiceType;
     function: ChatNamedToolChoiceFunction;
+    type: ChatNamedToolChoiceType;
 };
 /** @internal */
-export declare const ChatNamedToolChoiceType$outboundSchema: z.ZodEnum<typeof ChatNamedToolChoiceType>;
-/** @internal */
 export type ChatNamedToolChoiceFunction$Outbound = {
     name: string;
 };
@@ -27,9 +25,11 @@ export type ChatNamedToolChoiceFunction$Outbound = {
 export declare const ChatNamedToolChoiceFunction$outboundSchema: z.ZodType<ChatNamedToolChoiceFunction$Outbound, ChatNamedToolChoiceFunction>;
 export declare function chatNamedToolChoiceFunctionToJSON(chatNamedToolChoiceFunction: ChatNamedToolChoiceFunction): string;
 /** @internal */
+export declare const ChatNamedToolChoiceType$outboundSchema: z.ZodEnum<typeof ChatNamedToolChoiceType>;
+/** @internal */
 export type ChatNamedToolChoice$Outbound = {
-    type: string;
     function: ChatNamedToolChoiceFunction$Outbound;
+    type: string;
 };
 /** @internal */
 export declare const ChatNamedToolChoice$outboundSchema: z.ZodType<ChatNamedToolChoice$Outbound, ChatNamedToolChoice>;

package/esm/models/chatnamedtoolchoice.js

@@ -7,8 +7,6 @@ export const ChatNamedToolChoiceType = {
     Function: "function",
 };
 /** @internal */
-export const ChatNamedToolChoiceType$outboundSchema = z.enum(ChatNamedToolChoiceType);
-/** @internal */
 export const ChatNamedToolChoiceFunction$outboundSchema = z.object({
     name: z.string(),
 });
@@ -16,9 +14,11 @@ export function chatNamedToolChoiceFunctionToJSON(chatNamedToolChoiceFunction) {
     return JSON.stringify(ChatNamedToolChoiceFunction$outboundSchema.parse(chatNamedToolChoiceFunction));
 }
 /** @internal */
+export const ChatNamedToolChoiceType$outboundSchema = z.enum(ChatNamedToolChoiceType);
+/** @internal */
 export const ChatNamedToolChoice$outboundSchema = z.object({
-    type: ChatNamedToolChoiceType$outboundSchema,
     function: z.lazy(() => ChatNamedToolChoiceFunction$outboundSchema),
+    type: ChatNamedToolChoiceType$outboundSchema,
 });
 export function chatNamedToolChoiceToJSON(chatNamedToolChoice) {
     return JSON.stringify(ChatNamedToolChoice$outboundSchema.parse(chatNamedToolChoice));