@openrouter/sdk 0.1.13 → 0.1.17

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.13";
+    readonly sdkVersion: "0.1.17";
     readonly genVersion: "2.755.9";
-    readonly userAgent: "speakeasy-sdk/typescript 0.1.13 2.755.9 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.1.17 2.755.9 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.13",
+    sdkVersion: "0.1.17",
     genVersion: "2.755.9",
-    userAgent: "speakeasy-sdk/typescript 0.1.13 2.755.9 1.0.0 @openrouter/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.1.17 2.755.9 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/models/chatmessagecontentitem.d.ts

@@ -1,6 +1,7 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { ChatMessageContentItemAudio, ChatMessageContentItemAudio$Outbound } from "./chatmessagecontentitemaudio.js";
+import { ChatMessageContentItemFile, ChatMessageContentItemFile$Outbound } from "./chatmessagecontentitemfile.js";
 import { ChatMessageContentItemImage, ChatMessageContentItemImage$Outbound } from "./chatmessagecontentitemimage.js";
 import { ChatMessageContentItemText, ChatMessageContentItemText$Outbound } from "./chatmessagecontentitemtext.js";
 import { ChatMessageContentItemVideo, ChatMessageContentItemVideo$Outbound } from "./chatmessagecontentitemvideo.js";
@@ -11,6 +12,8 @@ export type ChatMessageContentItem = (ChatMessageContentItemText & {
     type: "image_url";
 }) | (ChatMessageContentItemAudio & {
     type: "input_audio";
+}) | (ChatMessageContentItemFile & {
+    type: "file";
 }) | (ChatMessageContentItemVideo & {
     type: "input_video";
 }) | (ChatMessageContentItemVideo & {
@@ -25,6 +28,8 @@ export type ChatMessageContentItem$Outbound = (ChatMessageContentItemText$Outbou
     type: "image_url";
 }) | (ChatMessageContentItemAudio$Outbound & {
     type: "input_audio";
+}) | (ChatMessageContentItemFile$Outbound & {
+    type: "file";
 }) | (ChatMessageContentItemVideo$Outbound & {
     type: "input_video";
 }) | (ChatMessageContentItemVideo$Outbound & {

package/esm/models/chatmessagecontentitem.js

@@ -4,6 +4,7 @@
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 import { ChatMessageContentItemAudio$inboundSchema, ChatMessageContentItemAudio$outboundSchema, } from "./chatmessagecontentitemaudio.js";
+import { ChatMessageContentItemFile$inboundSchema, ChatMessageContentItemFile$outboundSchema, } from "./chatmessagecontentitemfile.js";
 import { ChatMessageContentItemImage$inboundSchema, ChatMessageContentItemImage$outboundSchema, } from "./chatmessagecontentitemimage.js";
 import { ChatMessageContentItemText$inboundSchema, ChatMessageContentItemText$outboundSchema, } from "./chatmessagecontentitemtext.js";
 import { ChatMessageContentItemVideo$inboundSchema, ChatMessageContentItemVideo$outboundSchema, } from "./chatmessagecontentitemvideo.js";
@@ -12,6 +13,7 @@ export const ChatMessageContentItem$inboundSchema = z.union([
     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") })),
+    ChatMessageContentItemFile$inboundSchema.and(z.object({ type: z.literal("file") })),
     ChatMessageContentItemVideo$inboundSchema.and(z.object({ type: z.literal("input_video") })),
     z.lazy(() => ChatMessageContentItemVideo$inboundSchema).and(z.object({ type: z.literal("video_url") })),
 ]);
@@ -20,6 +22,7 @@ export const ChatMessageContentItem$outboundSchema = z.union([
     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") })),
+    ChatMessageContentItemFile$outboundSchema.and(z.object({ type: z.literal("file") })),
     ChatMessageContentItemVideo$outboundSchema.and(z.object({ type: z.literal("input_video") })),
     z.lazy(() => ChatMessageContentItemVideo$outboundSchema).and(z.object({ type: z.literal("video_url") })),
 ]);

package/esm/models/chatmessagecontentitemfile.d.ts

@@ -0,0 +1,36 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type FileT = {
+    fileData: string;
+    fileId?: string | undefined;
+    filename?: string | undefined;
+};
+export type ChatMessageContentItemFile = {
+    type: "file";
+    file: FileT;
+};
+/** @internal */
+export declare const FileT$inboundSchema: z.ZodType<FileT, unknown>;
+/** @internal */
+export type FileT$Outbound = {
+    file_data: string;
+    file_id?: string | undefined;
+    filename?: string | undefined;
+};
+/** @internal */
+export declare const FileT$outboundSchema: z.ZodType<FileT$Outbound, FileT>;
+export declare function fileToJSON(fileT: FileT): string;
+export declare function fileFromJSON(jsonString: string): SafeParseResult<FileT, SDKValidationError>;
+/** @internal */
+export declare const ChatMessageContentItemFile$inboundSchema: z.ZodType<ChatMessageContentItemFile, unknown>;
+/** @internal */
+export type ChatMessageContentItemFile$Outbound = {
+    type: "file";
+    file: FileT$Outbound;
+};
+/** @internal */
+export declare const ChatMessageContentItemFile$outboundSchema: z.ZodType<ChatMessageContentItemFile$Outbound, ChatMessageContentItemFile>;
+export declare function chatMessageContentItemFileToJSON(chatMessageContentItemFile: ChatMessageContentItemFile): string;
+export declare function chatMessageContentItemFileFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemFile, SDKValidationError>;
+//# sourceMappingURL=chatmessagecontentitemfile.d.ts.map

package/esm/models/chatmessagecontentitemfile.js

@@ -0,0 +1,51 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const FileT$inboundSchema = z.object({
+    file_data: z.string(),
+    file_id: z.string().optional(),
+    filename: z.string().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "file_data": "fileData",
+        "file_id": "fileId",
+    });
+});
+/** @internal */
+export const FileT$outboundSchema = z.object({
+    fileData: z.string(),
+    fileId: z.string().optional(),
+    filename: z.string().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        fileData: "file_data",
+        fileId: "file_id",
+    });
+});
+export function fileToJSON(fileT) {
+    return JSON.stringify(FileT$outboundSchema.parse(fileT));
+}
+export function fileFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FileT$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FileT' from JSON`);
+}
+/** @internal */
+export const ChatMessageContentItemFile$inboundSchema = z.object({
+    type: z.literal("file"),
+    file: z.lazy(() => FileT$inboundSchema),
+});
+/** @internal */
+export const ChatMessageContentItemFile$outboundSchema = z.object({
+    type: z.literal("file"),
+    file: z.lazy(() => FileT$outboundSchema),
+});
+export function chatMessageContentItemFileToJSON(chatMessageContentItemFile) {
+    return JSON.stringify(ChatMessageContentItemFile$outboundSchema.parse(chatMessageContentItemFile));
+}
+export function chatMessageContentItemFileFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatMessageContentItemFile$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemFile' from JSON`);
+}
+//# sourceMappingURL=chatmessagecontentitemfile.js.map

package/esm/models/chatmessagecontentitemvideo.d.ts

@@ -1,58 +1,46 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export type VideoUrl2 = {
+import { VideoURL, VideoURL$Outbound } from "./videourl.js";
+export type ChatMessageContentItemVideoVideoUrlVideoUrl = {
     url: string;
 };
 export type ChatMessageContentItemVideoVideoURL = {
     type: "video_url";
-    videoUrl: VideoUrl2;
-};
-export type VideoUrl1 = {
-    url: string;
+    videoUrl: ChatMessageContentItemVideoVideoUrlVideoUrl;
 };
 export type ChatMessageContentItemVideoInputVideo = {
     type: "input_video";
-    videoUrl: VideoUrl1;
+    videoUrl: VideoURL;
 };
 export type ChatMessageContentItemVideo = ChatMessageContentItemVideoInputVideo | ChatMessageContentItemVideoVideoURL;
 /** @internal */
-export declare const VideoUrl2$inboundSchema: z.ZodType<VideoUrl2, unknown>;
+export declare const ChatMessageContentItemVideoVideoUrlVideoUrl$inboundSchema: z.ZodType<ChatMessageContentItemVideoVideoUrlVideoUrl, unknown>;
 /** @internal */
-export type VideoUrl2$Outbound = {
+export type ChatMessageContentItemVideoVideoUrlVideoUrl$Outbound = {
     url: string;
 };
 /** @internal */
-export declare const VideoUrl2$outboundSchema: z.ZodType<VideoUrl2$Outbound, VideoUrl2>;
-export declare function videoUrl2ToJSON(videoUrl2: VideoUrl2): string;
-export declare function videoUrl2FromJSON(jsonString: string): SafeParseResult<VideoUrl2, SDKValidationError>;
+export declare const ChatMessageContentItemVideoVideoUrlVideoUrl$outboundSchema: z.ZodType<ChatMessageContentItemVideoVideoUrlVideoUrl$Outbound, ChatMessageContentItemVideoVideoUrlVideoUrl>;
+export declare function chatMessageContentItemVideoVideoUrlVideoUrlToJSON(chatMessageContentItemVideoVideoUrlVideoUrl: ChatMessageContentItemVideoVideoUrlVideoUrl): string;
+export declare function chatMessageContentItemVideoVideoUrlVideoUrlFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemVideoVideoUrlVideoUrl, SDKValidationError>;
 /** @internal */
 export declare const ChatMessageContentItemVideoVideoURL$inboundSchema: z.ZodType<ChatMessageContentItemVideoVideoURL, unknown>;
 /** @internal */
 export type ChatMessageContentItemVideoVideoURL$Outbound = {
     type: "video_url";
-    video_url: VideoUrl2$Outbound;
+    video_url: ChatMessageContentItemVideoVideoUrlVideoUrl$Outbound;
 };
 /** @internal */
 export declare const ChatMessageContentItemVideoVideoURL$outboundSchema: z.ZodType<ChatMessageContentItemVideoVideoURL$Outbound, ChatMessageContentItemVideoVideoURL>;
 export declare function chatMessageContentItemVideoVideoURLToJSON(chatMessageContentItemVideoVideoURL: ChatMessageContentItemVideoVideoURL): string;
 export declare function chatMessageContentItemVideoVideoURLFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemVideoVideoURL, SDKValidationError>;
 /** @internal */
-export declare const VideoUrl1$inboundSchema: z.ZodType<VideoUrl1, unknown>;
-/** @internal */
-export type VideoUrl1$Outbound = {
-    url: string;
-};
-/** @internal */
-export declare const VideoUrl1$outboundSchema: z.ZodType<VideoUrl1$Outbound, VideoUrl1>;
-export declare function videoUrl1ToJSON(videoUrl1: VideoUrl1): string;
-export declare function videoUrl1FromJSON(jsonString: string): SafeParseResult<VideoUrl1, SDKValidationError>;
-/** @internal */
 export declare const ChatMessageContentItemVideoInputVideo$inboundSchema: z.ZodType<ChatMessageContentItemVideoInputVideo, unknown>;
 /** @internal */
 export type ChatMessageContentItemVideoInputVideo$Outbound = {
     type: "input_video";
-    video_url: VideoUrl1$Outbound;
+    video_url: VideoURL$Outbound;
 };
 /** @internal */
 export declare const ChatMessageContentItemVideoInputVideo$outboundSchema: z.ZodType<ChatMessageContentItemVideoInputVideo$Outbound, ChatMessageContentItemVideoInputVideo>;

package/esm/models/chatmessagecontentitemvideo.js

@@ -4,24 +4,25 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+import { VideoURL$inboundSchema, VideoURL$outboundSchema, } from "./videourl.js";
 /** @internal */
-export const VideoUrl2$inboundSchema = z.object({
+export const ChatMessageContentItemVideoVideoUrlVideoUrl$inboundSchema = z.object({
     url: z.string(),
 });
 /** @internal */
-export const VideoUrl2$outboundSchema = z.object({
+export const ChatMessageContentItemVideoVideoUrlVideoUrl$outboundSchema = z.object({
     url: z.string(),
 });
-export function videoUrl2ToJSON(videoUrl2) {
-    return JSON.stringify(VideoUrl2$outboundSchema.parse(videoUrl2));
+export function chatMessageContentItemVideoVideoUrlVideoUrlToJSON(chatMessageContentItemVideoVideoUrlVideoUrl) {
+    return JSON.stringify(ChatMessageContentItemVideoVideoUrlVideoUrl$outboundSchema.parse(chatMessageContentItemVideoVideoUrlVideoUrl));
 }
-export function videoUrl2FromJSON(jsonString) {
-    return safeParse(jsonString, (x) => VideoUrl2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'VideoUrl2' from JSON`);
+export function chatMessageContentItemVideoVideoUrlVideoUrlFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatMessageContentItemVideoVideoUrlVideoUrl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemVideoVideoUrlVideoUrl' from JSON`);
 }
 /** @internal */
 export const ChatMessageContentItemVideoVideoURL$inboundSchema = z.object({
     type: z.literal("video_url"),
-    video_url: z.lazy(() => VideoUrl2$inboundSchema),
+    video_url: z.lazy(() => ChatMessageContentItemVideoVideoUrlVideoUrl$inboundSchema),
 }).transform((v) => {
     return remap$(v, {
         "video_url": "videoUrl",
@@ -30,7 +31,7 @@ export const ChatMessageContentItemVideoVideoURL$inboundSchema = z.object({
 /** @internal */
 export const ChatMessageContentItemVideoVideoURL$outboundSchema = z.object({
     type: z.literal("video_url"),
-    videoUrl: z.lazy(() => VideoUrl2$outboundSchema),
+    videoUrl: z.lazy(() => ChatMessageContentItemVideoVideoUrlVideoUrl$outboundSchema),
 }).transform((v) => {
     return remap$(v, {
         videoUrl: "video_url",
@@ -43,23 +44,9 @@ export function chatMessageContentItemVideoVideoURLFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ChatMessageContentItemVideoVideoURL$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemVideoVideoURL' from JSON`);
 }
 /** @internal */
-export const VideoUrl1$inboundSchema = z.object({
-    url: z.string(),
-});
-/** @internal */
-export const VideoUrl1$outboundSchema = z.object({
-    url: z.string(),
-});
-export function videoUrl1ToJSON(videoUrl1) {
-    return JSON.stringify(VideoUrl1$outboundSchema.parse(videoUrl1));
-}
-export function videoUrl1FromJSON(jsonString) {
-    return safeParse(jsonString, (x) => VideoUrl1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'VideoUrl1' from JSON`);
-}
-/** @internal */
 export const ChatMessageContentItemVideoInputVideo$inboundSchema = z.object({
     type: z.literal("input_video"),
-    video_url: z.lazy(() => VideoUrl1$inboundSchema),
+    video_url: VideoURL$inboundSchema,
 }).transform((v) => {
     return remap$(v, {
         "video_url": "videoUrl",
@@ -68,7 +55,7 @@ export const ChatMessageContentItemVideoInputVideo$inboundSchema = z.object({
 /** @internal */
 export const ChatMessageContentItemVideoInputVideo$outboundSchema = z.object({
     type: z.literal("input_video"),
-    videoUrl: z.lazy(() => VideoUrl1$outboundSchema),
+    videoUrl: VideoURL$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         videoUrl: "video_url",

package/esm/models/index.d.ts

@@ -7,6 +7,7 @@ export * from "./chatgenerationparams.js";
 export * from "./chatgenerationtokenusage.js";
 export * from "./chatmessagecontentitem.js";
 export * from "./chatmessagecontentitemaudio.js";
+export * from "./chatmessagecontentitemfile.js";
 export * from "./chatmessagecontentitemimage.js";
 export * from "./chatmessagecontentitemtext.js";
 export * from "./chatmessagecontentitemvideo.js";
@@ -137,6 +138,7 @@ export * from "./unauthorizedresponseerrordata.js";
 export * from "./unprocessableentityresponseerrordata.js";
 export * from "./urlcitation.js";
 export * from "./usermessage.js";
+export * from "./videourl.js";
 export * from "./websearchpreviewtooluserlocation.js";
 export * from "./websearchstatus.js";
 //# sourceMappingURL=index.d.ts.map

package/esm/models/index.js

@@ -10,6 +10,7 @@ export * from "./chatgenerationparams.js";
 export * from "./chatgenerationtokenusage.js";
 export * from "./chatmessagecontentitem.js";
 export * from "./chatmessagecontentitemaudio.js";
+export * from "./chatmessagecontentitemfile.js";
 export * from "./chatmessagecontentitemimage.js";
 export * from "./chatmessagecontentitemtext.js";
 export * from "./chatmessagecontentitemvideo.js";
@@ -140,6 +141,7 @@ export * from "./unauthorizedresponseerrordata.js";
 export * from "./unprocessableentityresponseerrordata.js";
 export * from "./urlcitation.js";
 export * from "./usermessage.js";
+export * from "./videourl.js";
 export * from "./websearchpreviewtooluserlocation.js";
 export * from "./websearchstatus.js";
 //# sourceMappingURL=index.js.map

package/esm/models/videourl.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type VideoURL = {
+    url: string;
+};
+/** @internal */
+export declare const VideoURL$inboundSchema: z.ZodType<VideoURL, unknown>;
+/** @internal */
+export type VideoURL$Outbound = {
+    url: string;
+};
+/** @internal */
+export declare const VideoURL$outboundSchema: z.ZodType<VideoURL$Outbound, VideoURL>;
+export declare function videoURLToJSON(videoURL: VideoURL): string;
+export declare function videoURLFromJSON(jsonString: string): SafeParseResult<VideoURL, SDKValidationError>;
+//# sourceMappingURL=videourl.d.ts.map

package/esm/models/videourl.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const VideoURL$inboundSchema = z.object({
+    url: z.string(),
+});
+/** @internal */
+export const VideoURL$outboundSchema = z
+    .object({
+    url: z.string(),
+});
+export function videoURLToJSON(videoURL) {
+    return JSON.stringify(VideoURL$outboundSchema.parse(videoURL));
+}
+export function videoURLFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => VideoURL$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'VideoURL' from JSON`);
+}
+//# sourceMappingURL=videourl.js.map

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "0.1.13",
+  "version": "0.1.17",
   "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": [