@openrouter/sdk 0.8.0 → 0.10.2

package/esm/models/assistantmessage.d.ts

@@ -1,66 +1,83 @@
 import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
+import { AssistantMessageImages, AssistantMessageImages$Outbound } from "./assistantmessageimages.js";
+import { ChatCompletionAudioOutput, ChatCompletionAudioOutput$Outbound } from "./chatcompletionaudiooutput.js";
 import { ChatMessageContentItem, ChatMessageContentItem$Outbound } from "./chatmessagecontentitem.js";
 import { ChatMessageToolCall, ChatMessageToolCall$Outbound } from "./chatmessagetoolcall.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { Schema19, Schema19$Outbound } from "./schema19.js";
-export type AssistantMessageContent = string | Array<ChatMessageContentItem>;
-export type AssistantMessageImageUrl = {
-    url: string;
-};
-export type Image = {
-    imageUrl: AssistantMessageImageUrl;
+import { ReasoningDetailUnion, ReasoningDetailUnion$Outbound } from "./reasoningdetailunion.js";
+export declare const AssistantMessageRole: {
+    readonly Assistant: "assistant";
 };
+export type AssistantMessageRole = ClosedEnum<typeof AssistantMessageRole>;
+/**
+ * Assistant message content
+ */
+export type AssistantMessageContent = string | Array<ChatMessageContentItem> | any;
+/**
+ * Assistant message for requests and responses
+ */
 export type AssistantMessage = {
-    role: "assistant";
-    content?: string | Array<ChatMessageContentItem> | null | undefined;
+    role: AssistantMessageRole;
+    /**
+     * Assistant message content
+     */
+    content?: string | Array<ChatMessageContentItem> | any | null | undefined;
+    /**
+     * Optional name for the assistant
+     */
     name?: string | undefined;
+    /**
+     * Tool calls made by the assistant
+     */
     toolCalls?: Array<ChatMessageToolCall> | undefined;
+    /**
+     * Refusal message if content was refused
+     */
     refusal?: string | null | undefined;
+    /**
+     * Reasoning output
+     */
     reasoning?: string | null | undefined;
-    reasoningDetails?: Array<Schema19> | undefined;
-    images?: Array<Image> | undefined;
+    /**
+     * Reasoning details for extended thinking models
+     */
+    reasoningDetails?: Array<ReasoningDetailUnion> | undefined;
+    /**
+     * Generated images from image generation models
+     */
+    images?: Array<AssistantMessageImages> | undefined;
+    /**
+     * Audio output data or reference
+     */
+    audio?: ChatCompletionAudioOutput | undefined;
 };
 /** @internal */
+export declare const AssistantMessageRole$inboundSchema: z.ZodEnum<typeof AssistantMessageRole>;
+/** @internal */
+export declare const AssistantMessageRole$outboundSchema: z.ZodEnum<typeof AssistantMessageRole>;
+/** @internal */
 export declare const AssistantMessageContent$inboundSchema: z.ZodType<AssistantMessageContent, unknown>;
 /** @internal */
-export type AssistantMessageContent$Outbound = string | Array<ChatMessageContentItem$Outbound>;
+export type AssistantMessageContent$Outbound = string | Array<ChatMessageContentItem$Outbound> | any;
 /** @internal */
 export declare const AssistantMessageContent$outboundSchema: z.ZodType<AssistantMessageContent$Outbound, AssistantMessageContent>;
 export declare function assistantMessageContentToJSON(assistantMessageContent: AssistantMessageContent): string;
 export declare function assistantMessageContentFromJSON(jsonString: string): SafeParseResult<AssistantMessageContent, SDKValidationError>;
 /** @internal */
-export declare const AssistantMessageImageUrl$inboundSchema: z.ZodType<AssistantMessageImageUrl, unknown>;
-/** @internal */
-export type AssistantMessageImageUrl$Outbound = {
-    url: string;
-};
-/** @internal */
-export declare const AssistantMessageImageUrl$outboundSchema: z.ZodType<AssistantMessageImageUrl$Outbound, AssistantMessageImageUrl>;
-export declare function assistantMessageImageUrlToJSON(assistantMessageImageUrl: AssistantMessageImageUrl): string;
-export declare function assistantMessageImageUrlFromJSON(jsonString: string): SafeParseResult<AssistantMessageImageUrl, SDKValidationError>;
-/** @internal */
-export declare const Image$inboundSchema: z.ZodType<Image, unknown>;
-/** @internal */
-export type Image$Outbound = {
-    image_url: AssistantMessageImageUrl$Outbound;
-};
-/** @internal */
-export declare const Image$outboundSchema: z.ZodType<Image$Outbound, Image>;
-export declare function imageToJSON(image: Image): string;
-export declare function imageFromJSON(jsonString: string): SafeParseResult<Image, SDKValidationError>;
-/** @internal */
 export declare const AssistantMessage$inboundSchema: z.ZodType<AssistantMessage, unknown>;
 /** @internal */
 export type AssistantMessage$Outbound = {
-    role: "assistant";
-    content?: string | Array<ChatMessageContentItem$Outbound> | null | undefined;
+    role: string;
+    content?: string | Array<ChatMessageContentItem$Outbound> | any | null | undefined;
     name?: string | undefined;
     tool_calls?: Array<ChatMessageToolCall$Outbound> | undefined;
     refusal?: string | null | undefined;
     reasoning?: string | null | undefined;
-    reasoning_details?: Array<Schema19$Outbound> | undefined;
-    images?: Array<Image$Outbound> | undefined;
+    reasoning_details?: Array<ReasoningDetailUnion$Outbound> | undefined;
+    images?: Array<AssistantMessageImages$Outbound> | undefined;
+    audio?: ChatCompletionAudioOutput$Outbound | undefined;
 };
 /** @internal */
 export declare const AssistantMessage$outboundSchema: z.ZodType<AssistantMessage$Outbound, AssistantMessage>;

package/esm/models/assistantmessage.js

@@ -5,13 +5,30 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+import { AssistantMessageImages$inboundSchema, AssistantMessageImages$outboundSchema, } from "./assistantmessageimages.js";
+import { ChatCompletionAudioOutput$inboundSchema, ChatCompletionAudioOutput$outboundSchema, } from "./chatcompletionaudiooutput.js";
 import { ChatMessageContentItem$inboundSchema, ChatMessageContentItem$outboundSchema, } from "./chatmessagecontentitem.js";
 import { ChatMessageToolCall$inboundSchema, ChatMessageToolCall$outboundSchema, } from "./chatmessagetoolcall.js";
-import { Schema19$inboundSchema, Schema19$outboundSchema, } from "./schema19.js";
+import { ReasoningDetailUnion$inboundSchema, ReasoningDetailUnion$outboundSchema, } from "./reasoningdetailunion.js";
+export const AssistantMessageRole = {
+    Assistant: "assistant",
+};
 /** @internal */
-export const AssistantMessageContent$inboundSchema = z.union([z.string(), z.array(ChatMessageContentItem$inboundSchema)]);
+export const AssistantMessageRole$inboundSchema = z.enum(AssistantMessageRole);
 /** @internal */
-export const AssistantMessageContent$outboundSchema = z.union([z.string(), z.array(ChatMessageContentItem$outboundSchema)]);
+export const AssistantMessageRole$outboundSchema = AssistantMessageRole$inboundSchema;
+/** @internal */
+export const AssistantMessageContent$inboundSchema = z.union([
+    z.string(),
+    z.array(ChatMessageContentItem$inboundSchema),
+    z.any(),
+]);
+/** @internal */
+export const AssistantMessageContent$outboundSchema = z.union([
+    z.string(),
+    z.array(ChatMessageContentItem$outboundSchema),
+    z.any(),
+]);
 export function assistantMessageContentToJSON(assistantMessageContent) {
     return JSON.stringify(AssistantMessageContent$outboundSchema.parse(assistantMessageContent));
 }
@@ -19,51 +36,20 @@ export function assistantMessageContentFromJSON(jsonString) {
     return safeParse(jsonString, (x) => AssistantMessageContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AssistantMessageContent' from JSON`);
 }
 /** @internal */
-export const AssistantMessageImageUrl$inboundSchema = z.object({
-    url: z.string(),
-});
-/** @internal */
-export const AssistantMessageImageUrl$outboundSchema = z.object({
-    url: z.string(),
-});
-export function assistantMessageImageUrlToJSON(assistantMessageImageUrl) {
-    return JSON.stringify(AssistantMessageImageUrl$outboundSchema.parse(assistantMessageImageUrl));
-}
-export function assistantMessageImageUrlFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => AssistantMessageImageUrl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AssistantMessageImageUrl' from JSON`);
-}
-/** @internal */
-export const Image$inboundSchema = z.object({
-    image_url: z.lazy(() => AssistantMessageImageUrl$inboundSchema),
-}).transform((v) => {
-    return remap$(v, {
-        "image_url": "imageUrl",
-    });
-});
-/** @internal */
-export const Image$outboundSchema = z.object({
-    imageUrl: z.lazy(() => AssistantMessageImageUrl$outboundSchema),
-}).transform((v) => {
-    return remap$(v, {
-        imageUrl: "image_url",
-    });
-});
-export function imageToJSON(image) {
-    return JSON.stringify(Image$outboundSchema.parse(image));
-}
-export function imageFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Image$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Image' from JSON`);
-}
-/** @internal */
 export const AssistantMessage$inboundSchema = z.object({
-    role: z.literal("assistant"),
-    content: z.nullable(z.union([z.string(), z.array(ChatMessageContentItem$inboundSchema)])).optional(),
+    role: AssistantMessageRole$inboundSchema,
+    content: z.nullable(z.union([
+        z.string(),
+        z.array(ChatMessageContentItem$inboundSchema),
+        z.any(),
+    ])).optional(),
     name: z.string().optional(),
     tool_calls: z.array(ChatMessageToolCall$inboundSchema).optional(),
     refusal: z.nullable(z.string()).optional(),
     reasoning: z.nullable(z.string()).optional(),
-    reasoning_details: z.array(Schema19$inboundSchema).optional(),
-    images: z.array(z.lazy(() => Image$inboundSchema)).optional(),
+    reasoning_details: z.array(ReasoningDetailUnion$inboundSchema).optional(),
+    images: z.array(AssistantMessageImages$inboundSchema).optional(),
+    audio: ChatCompletionAudioOutput$inboundSchema.optional(),
 }).transform((v) => {
     return remap$(v, {
         "tool_calls": "toolCalls",
@@ -72,14 +58,19 @@ export const AssistantMessage$inboundSchema = z.object({
 });
 /** @internal */
 export const AssistantMessage$outboundSchema = z.object({
-    role: z.literal("assistant"),
-    content: z.nullable(z.union([z.string(), z.array(ChatMessageContentItem$outboundSchema)])).optional(),
+    role: AssistantMessageRole$outboundSchema,
+    content: z.nullable(z.union([
+        z.string(),
+        z.array(ChatMessageContentItem$outboundSchema),
+        z.any(),
+    ])).optional(),
     name: z.string().optional(),
     toolCalls: z.array(ChatMessageToolCall$outboundSchema).optional(),
     refusal: z.nullable(z.string()).optional(),
     reasoning: z.nullable(z.string()).optional(),
-    reasoningDetails: z.array(Schema19$outboundSchema).optional(),
-    images: z.array(z.lazy(() => Image$outboundSchema)).optional(),
+    reasoningDetails: z.array(ReasoningDetailUnion$outboundSchema).optional(),
+    images: z.array(AssistantMessageImages$outboundSchema).optional(),
+    audio: ChatCompletionAudioOutput$outboundSchema.optional(),
 }).transform((v) => {
     return remap$(v, {
         toolCalls: "tool_calls",

package/esm/models/assistantmessageimages.d.ts

@@ -0,0 +1,33 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AssistantMessageImagesImageUrl = {
+    /**
+     * URL or base64-encoded data of the generated image
+     */
+    url: string;
+};
+export type AssistantMessageImages = {
+    imageUrl: AssistantMessageImagesImageUrl;
+};
+/** @internal */
+export declare const AssistantMessageImagesImageUrl$inboundSchema: z.ZodType<AssistantMessageImagesImageUrl, unknown>;
+/** @internal */
+export type AssistantMessageImagesImageUrl$Outbound = {
+    url: string;
+};
+/** @internal */
+export declare const AssistantMessageImagesImageUrl$outboundSchema: z.ZodType<AssistantMessageImagesImageUrl$Outbound, AssistantMessageImagesImageUrl>;
+export declare function assistantMessageImagesImageUrlToJSON(assistantMessageImagesImageUrl: AssistantMessageImagesImageUrl): string;
+export declare function assistantMessageImagesImageUrlFromJSON(jsonString: string): SafeParseResult<AssistantMessageImagesImageUrl, SDKValidationError>;
+/** @internal */
+export declare const AssistantMessageImages$inboundSchema: z.ZodType<AssistantMessageImages, unknown>;
+/** @internal */
+export type AssistantMessageImages$Outbound = {
+    image_url: AssistantMessageImagesImageUrl$Outbound;
+};
+/** @internal */
+export declare const AssistantMessageImages$outboundSchema: z.ZodType<AssistantMessageImages$Outbound, AssistantMessageImages>;
+export declare function assistantMessageImagesToJSON(assistantMessageImages: AssistantMessageImages): string;
+export declare function assistantMessageImagesFromJSON(jsonString: string): SafeParseResult<AssistantMessageImages, SDKValidationError>;
+//# sourceMappingURL=assistantmessageimages.d.ts.map

package/esm/models/assistantmessageimages.js

@@ -0,0 +1,44 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7b893584cc21
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const AssistantMessageImagesImageUrl$inboundSchema = z.object({
+    url: z.string(),
+});
+/** @internal */
+export const AssistantMessageImagesImageUrl$outboundSchema = z.object({
+    url: z.string(),
+});
+export function assistantMessageImagesImageUrlToJSON(assistantMessageImagesImageUrl) {
+    return JSON.stringify(AssistantMessageImagesImageUrl$outboundSchema.parse(assistantMessageImagesImageUrl));
+}
+export function assistantMessageImagesImageUrlFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AssistantMessageImagesImageUrl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AssistantMessageImagesImageUrl' from JSON`);
+}
+/** @internal */
+export const AssistantMessageImages$inboundSchema = z.object({
+    image_url: z.lazy(() => AssistantMessageImagesImageUrl$inboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        "image_url": "imageUrl",
+    });
+});
+/** @internal */
+export const AssistantMessageImages$outboundSchema = z.object({
+    imageUrl: z.lazy(() => AssistantMessageImagesImageUrl$outboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        imageUrl: "image_url",
+    });
+});
+export function assistantMessageImagesToJSON(assistantMessageImages) {
+    return JSON.stringify(AssistantMessageImages$outboundSchema.parse(assistantMessageImages));
+}
+export function assistantMessageImagesFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AssistantMessageImages$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AssistantMessageImages' from JSON`);
+}
+//# sourceMappingURL=assistantmessageimages.js.map

package/esm/models/chatcompletionaudiooutput.d.ts

@@ -0,0 +1,38 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Audio output data or reference
+ */
+export type ChatCompletionAudioOutput = {
+    /**
+     * Audio output identifier
+     */
+    id?: string | undefined;
+    /**
+     * Audio expiration timestamp
+     */
+    expiresAt?: number | undefined;
+    /**
+     * Base64 encoded audio data
+     */
+    data?: string | undefined;
+    /**
+     * Audio transcript
+     */
+    transcript?: string | undefined;
+};
+/** @internal */
+export declare const ChatCompletionAudioOutput$inboundSchema: z.ZodType<ChatCompletionAudioOutput, unknown>;
+/** @internal */
+export type ChatCompletionAudioOutput$Outbound = {
+    id?: string | undefined;
+    expires_at?: number | undefined;
+    data?: string | undefined;
+    transcript?: string | undefined;
+};
+/** @internal */
+export declare const ChatCompletionAudioOutput$outboundSchema: z.ZodType<ChatCompletionAudioOutput$Outbound, ChatCompletionAudioOutput>;
+export declare function chatCompletionAudioOutputToJSON(chatCompletionAudioOutput: ChatCompletionAudioOutput): string;
+export declare function chatCompletionAudioOutputFromJSON(jsonString: string): SafeParseResult<ChatCompletionAudioOutput, SDKValidationError>;
+//# sourceMappingURL=chatcompletionaudiooutput.d.ts.map

package/esm/models/chatcompletionaudiooutput.js

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 125d1fe30400
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const ChatCompletionAudioOutput$inboundSchema = z.object({
+    id: z.string().optional(),
+    expires_at: z.number().optional(),
+    data: z.string().optional(),
+    transcript: z.string().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "expires_at": "expiresAt",
+    });
+});
+/** @internal */
+export const ChatCompletionAudioOutput$outboundSchema = z.object({
+    id: z.string().optional(),
+    expiresAt: z.number().optional(),
+    data: z.string().optional(),
+    transcript: z.string().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        expiresAt: "expires_at",
+    });
+});
+export function chatCompletionAudioOutputToJSON(chatCompletionAudioOutput) {
+    return JSON.stringify(ChatCompletionAudioOutput$outboundSchema.parse(chatCompletionAudioOutput));
+}
+export function chatCompletionAudioOutputFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatCompletionAudioOutput$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatCompletionAudioOutput' from JSON`);
+}
+//# sourceMappingURL=chatcompletionaudiooutput.js.map