@openrouter/sdk 0.1.13 → 0.1.18

package/README.md

@@ -19,32 +19,24 @@ The SDK can be installed with either [npm](https://www.npmjs.com/), [pnpm](https
 
 ```bash
 npm add @openrouter/sdk
-# Install optional peer dependencies if you plan to use React hooks
-npm add @tanstack/react-query react react-dom
 ```
 
 ### PNPM
 
 ```bash
 pnpm add @openrouter/sdk
-# Install optional peer dependencies if you plan to use React hooks
-pnpm add @tanstack/react-query react react-dom
 ```
 
 ### Bun
 
 ```bash
 bun add @openrouter/sdk
-# Install optional peer dependencies if you plan to use React hooks
-bun add @tanstack/react-query react react-dom
 ```
 
 ### Yarn
 
 ```bash
 yarn add @openrouter/sdk
-# Install optional peer dependencies if you plan to use React hooks
-yarn add @tanstack/react-query react react-dom
 ```
 
 > [!NOTE]

package/esm/lib/config.d.ts

@@ -13,6 +13,14 @@ export declare const ServerList: {
 };
 export type SDKOptions = {
     apiKey?: string | (() => Promise<string>) | undefined;
+    /**
+     * Allows setting the httpReferer parameter for all supported operations
+     */
+    httpReferer?: string | undefined;
+    /**
+     * Allows setting the xTitle parameter for all supported operations
+     */
+    xTitle?: string | undefined;
     httpClient?: HTTPClient;
     /**
      * Allows overriding the default server used by the SDK
@@ -37,8 +45,8 @@ export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "0.1.13";
+    readonly sdkVersion: "0.1.18";
     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.18 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.18",
     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.18 2.755.9 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/lib/env.d.ts

@@ -1,6 +1,15 @@
 import * as z from "zod/v4";
+import { SDKOptions } from "./config.js";
 export interface Env {
     OPENROUTER_API_KEY?: string | undefined;
+    /**
+     * Sets the httpReferer parameter for all supported operations
+     */
+    OPENROUTER_HTTP_REFERER?: string | undefined;
+    /**
+     * Sets the xTitle parameter for all supported operations
+     */
+    OPENROUTER_X_TITLE?: string | undefined;
     OPENROUTER_DEBUG?: boolean | undefined;
 }
 export declare const envSchema: z.ZodType<Env, unknown>;
@@ -12,4 +21,8 @@ export declare function env(): Env;
  * Clears the cached env object. Useful for testing with a fresh environment.
  */
 export declare function resetEnv(): void;
+/**
+ * Populates global parameters with environment variables.
+ */
+export declare function fillGlobals(options: SDKOptions): SDKOptions;
 //# sourceMappingURL=env.d.ts.map

package/esm/lib/env.js

@@ -5,6 +5,8 @@ import * as z from "zod/v4";
 import { dlv } from "./dlv.js";
 export const envSchema = z.object({
     OPENROUTER_API_KEY: z.string().optional(),
+    OPENROUTER_HTTP_REFERER: z.string().optional(),
+    OPENROUTER_X_TITLE: z.string().optional(),
     OPENROUTER_DEBUG: z.coerce.boolean().optional(),
 });
 /**
@@ -41,4 +43,18 @@ export function env() {
 export function resetEnv() {
     envMemo = undefined;
 }
+/**
+ * Populates global parameters with environment variables.
+ */
+export function fillGlobals(options) {
+    const clone = { ...options };
+    const envVars = env();
+    if (typeof envVars.OPENROUTER_HTTP_REFERER !== "undefined") {
+        clone.httpReferer ?? (clone.httpReferer = envVars.OPENROUTER_HTTP_REFERER);
+    }
+    if (typeof envVars.OPENROUTER_X_TITLE !== "undefined") {
+        clone.xTitle ?? (clone.xTitle = envVars.OPENROUTER_X_TITLE);
+    }
+    return clone;
+}
 //# sourceMappingURL=env.js.map

package/esm/lib/sdks.js

@@ -19,7 +19,7 @@ import { ERR, OK } from "../types/fp.js";
 import { stringToBase64 } from "./base64.js";
 import { SDK_METADATA, serverURLFromOptions } from "./config.js";
 import { encodeForm } from "./encodings.js";
-import { env } from "./env.js";
+import { env, fillGlobals } from "./env.js";
 import { HTTPClient, isAbortError, isConnectionError, isTimeoutError, matchContentType, matchStatusCode, } from "./http.js";
 import { retry } from "./retries.js";
 const gt = typeof globalThis === "undefined" ? null : globalThis;
@@ -54,7 +54,7 @@ export class ClientSDK {
         }
         this._baseURL = url;
         __classPrivateFieldSet(this, _ClientSDK_httpClient, options.httpClient || defaultHttpClient, "f");
-        this._options = { ...options, hooks: __classPrivateFieldGet(this, _ClientSDK_hooks, "f") };
+        this._options = { ...fillGlobals(options), hooks: __classPrivateFieldGet(this, _ClientSDK_hooks, "f") };
         __classPrivateFieldSet(this, _ClientSDK_logger, this._options.debugLogger, "f");
         if (!__classPrivateFieldGet(this, _ClientSDK_logger, "f") && env().OPENROUTER_DEBUG) {
             __classPrivateFieldSet(this, _ClientSDK_logger, console, "f");

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.18",
   "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.18",
   "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": [
@@ -48,11 +48,6 @@
       "types": "./esm/models/operations/index.d.ts",
       "default": "./esm/models/operations/index.js"
     },
-    "./react-query": {
-      "source": "./src/react-query/index.ts",
-      "types": "./esm/react-query/index.d.ts",
-      "default": "./esm/react-query/index.js"
-    },
     "./*.js": {
       "source": "./src/*.ts",
       "types": "./esm/*.d.ts",
@@ -75,20 +70,11 @@
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {
-    "@tanstack/react-query": "^5",
-    "react": "^18 || ^19",
-    "react-dom": "^18 || ^19"
-  },
-  "peerDependenciesMeta": {
-    "@tanstack/react-query": {"optional":true},
-    "react": {"optional":true},
-    "react-dom": {"optional":true}
+    
   },
   "devDependencies": {
     "@eslint/js": "^9.19.0",
-    "@tanstack/react-query": "^5.61.4",
     "@types/node": "^22.13.12",
-    "@types/react": "^18.3.12",
     "dotenv": "^16.4.7",
     "eslint": "^9.19.0",
     "globals": "^15.14.0",