@openrouter/sdk 0.10.2 → 0.12.0

package/esm/lib/chat-compat.test.js

@@ -1,285 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { fromChatMessages, toChatMessage } from "./chat-compat.js";
-/**
- * Creates a properly typed mock OpenResponsesNonStreamingResponse for testing.
- * This factory provides all required fields with sensible defaults.
- */
-function createMockResponse(overrides) {
-    return {
-        id: "resp_test",
-        object: "response",
-        createdAt: Date.now(),
-        completedAt: Date.now(),
-        model: "openai/gpt-4",
-        status: "completed",
-        error: null,
-        incompleteDetails: null,
-        temperature: null,
-        topP: null,
-        presencePenalty: null,
-        frequencyPenalty: null,
-        metadata: null,
-        tools: [],
-        toolChoice: "auto",
-        parallelToolCalls: false,
-        ...overrides,
-    };
-}
-describe("fromChatMessages", () => {
-    describe("basic message conversion", () => {
-        it("converts user message with string content", () => {
-            const messages = [
-                { role: "user", content: "Hello, how are you?" },
-            ];
-            const result = fromChatMessages(messages);
-            expect(result).toEqual([
-                { role: "user", content: "Hello, how are you?" },
-            ]);
-        });
-        it("converts assistant message with string content", () => {
-            const messages = [
-                { role: "assistant", content: "I am doing well, thank you!" },
-            ];
-            const result = fromChatMessages(messages);
-            expect(result).toEqual([
-                { role: "assistant", content: "I am doing well, thank you!" },
-            ]);
-        });
-        it("converts system message with string content", () => {
-            const messages = [
-                { role: "system", content: "You are a helpful assistant." },
-            ];
-            const result = fromChatMessages(messages);
-            expect(result).toEqual([
-                { role: "system", content: "You are a helpful assistant." },
-            ]);
-        });
-        it("converts developer message with string content", () => {
-            const messages = [
-                { role: "developer", content: "Developer instructions here." },
-            ];
-            const result = fromChatMessages(messages);
-            expect(result).toEqual([
-                { role: "developer", content: "Developer instructions here." },
-            ]);
-        });
-        it("converts multiple messages in conversation", () => {
-            const messages = [
-                { role: "system", content: "You are helpful." },
-                { role: "user", content: "Hi" },
-                { role: "assistant", content: "Hello!" },
-                { role: "user", content: "How are you?" },
-            ];
-            const result = fromChatMessages(messages);
-            expect(result).toEqual([
-                { role: "system", content: "You are helpful." },
-                { role: "user", content: "Hi" },
-                { role: "assistant", content: "Hello!" },
-                { role: "user", content: "How are you?" },
-            ]);
-        });
-    });
-    describe("tool response message conversion", () => {
-        it("converts tool message to function_call_output", () => {
-            const messages = [
-                {
-                    role: "tool",
-                    content: "The weather is sunny and 72F",
-                    toolCallId: "call_abc123",
-                },
-            ];
-            const result = fromChatMessages(messages);
-            expect(result).toEqual([
-                {
-                    type: "function_call_output",
-                    callId: "call_abc123",
-                    output: "The weather is sunny and 72F",
-                },
-            ]);
-        });
-        it("converts tool message with object content by stringifying", () => {
-            const messages = [
-                {
-                    role: "tool",
-                    content: [{ type: "text", text: "Structured response" }],
-                    toolCallId: "call_def456",
-                },
-            ];
-            const result = fromChatMessages(messages);
-            expect(result).toEqual([
-                {
-                    type: "function_call_output",
-                    callId: "call_def456",
-                    output: JSON.stringify([{ type: "text", text: "Structured response" }]),
-                },
-            ]);
-        });
-    });
-    describe("content array handling", () => {
-        it("stringifies array content for user messages", () => {
-            const messages = [
-                {
-                    role: "user",
-                    content: [{ type: "text", text: "Hello from array" }],
-                },
-            ];
-            const result = fromChatMessages(messages);
-            expect(result).toEqual([
-                {
-                    role: "user",
-                    content: JSON.stringify([{ type: "text", text: "Hello from array" }]),
-                },
-            ]);
-        });
-        it("stringifies array content for assistant messages", () => {
-            const messages = [
-                {
-                    role: "assistant",
-                    content: [{ type: "text", text: "Response in array" }],
-                },
-            ];
-            const result = fromChatMessages(messages);
-            expect(result).toEqual([
-                {
-                    role: "assistant",
-                    content: JSON.stringify([{ type: "text", text: "Response in array" }]),
-                },
-            ]);
-        });
-    });
-    describe("null and empty content handling", () => {
-        it("handles null content in assistant message", () => {
-            const messages = [
-                { role: "assistant", content: null },
-            ];
-            const result = fromChatMessages(messages);
-            expect(result).toEqual([{ role: "assistant", content: "" }]);
-        });
-        it("handles empty string content", () => {
-            const messages = [{ role: "user", content: "" }];
-            const result = fromChatMessages(messages);
-            expect(result).toEqual([{ role: "user", content: "" }]);
-        });
-        it("handles empty messages array", () => {
-            const result = fromChatMessages([]);
-            expect(result).toEqual([]);
-        });
-    });
-});
-describe("toChatMessage", () => {
-    describe("basic message conversion", () => {
-        it("converts response with text output to AssistantMessage", () => {
-            const response = createMockResponse({
-                id: "resp_123",
-                output: [
-                    {
-                        id: "msg_1",
-                        type: "message",
-                        role: "assistant",
-                        status: "completed",
-                        content: [
-                            {
-                                type: "output_text",
-                                text: "Hello! How can I help you?",
-                                annotations: [],
-                            },
-                        ],
-                    },
-                ],
-                usage: {
-                    inputTokens: 10,
-                    outputTokens: 20,
-                    totalTokens: 30,
-                    inputTokensDetails: { cachedTokens: 0 },
-                    outputTokensDetails: { reasoningTokens: 0 },
-                },
-            });
-            const result = toChatMessage(response);
-            expect(result).toEqual({
-                role: "assistant",
-                content: "Hello! How can I help you?",
-            });
-        });
-        it("combines multiple text parts into single content string", () => {
-            const response = createMockResponse({
-                id: "resp_456",
-                output: [
-                    {
-                        id: "msg_1",
-                        type: "message",
-                        role: "assistant",
-                        status: "completed",
-                        content: [
-                            { type: "output_text", text: "Part 1. ", annotations: [] },
-                            { type: "output_text", text: "Part 2.", annotations: [] },
-                        ],
-                    },
-                ],
-                usage: {
-                    inputTokens: 5,
-                    outputTokens: 10,
-                    totalTokens: 15,
-                    inputTokensDetails: { cachedTokens: 0 },
-                    outputTokensDetails: { reasoningTokens: 0 },
-                },
-            });
-            const result = toChatMessage(response);
-            expect(result).toEqual({
-                role: "assistant",
-                content: "Part 1. Part 2.",
-            });
-        });
-        it("returns null content when message has no text", () => {
-            const response = createMockResponse({
-                id: "resp_789",
-                output: [
-                    {
-                        id: "msg_1",
-                        type: "message",
-                        role: "assistant",
-                        status: "completed",
-                        content: [],
-                    },
-                ],
-                usage: {
-                    inputTokens: 5,
-                    outputTokens: 0,
-                    totalTokens: 5,
-                    inputTokensDetails: { cachedTokens: 0 },
-                    outputTokensDetails: { reasoningTokens: 0 },
-                },
-            });
-            const result = toChatMessage(response);
-            expect(result).toEqual({
-                role: "assistant",
-                content: null,
-            });
-        });
-    });
-    describe("error handling", () => {
-        it("throws error when no message found in output", () => {
-            const response = createMockResponse({
-                id: "resp_err",
-                output: [
-                    {
-                        type: "function_call",
-                        callId: "call_1",
-                        name: "test_tool",
-                        arguments: "{}",
-                        id: "fc_1",
-                        status: "completed",
-                    },
-                ],
-                usage: {
-                    inputTokens: 5,
-                    outputTokens: 10,
-                    totalTokens: 15,
-                    inputTokensDetails: { cachedTokens: 0 },
-                    outputTokensDetails: { reasoningTokens: 0 },
-                },
-            });
-            expect(() => toChatMessage(response)).toThrow("No message found in response output");
-        });
-    });
-});
-//# sourceMappingURL=chat-compat.test.js.map

package/esm/models/assistantmessage.d.ts

@@ -1,86 +0,0 @@
-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 { 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: 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;
-    /**
-     * 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> | 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 AssistantMessage$inboundSchema: z.ZodType<AssistantMessage, unknown>;
-/** @internal */
-export type AssistantMessage$Outbound = {
-    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<ReasoningDetailUnion$Outbound> | undefined;
-    images?: Array<AssistantMessageImages$Outbound> | undefined;
-    audio?: ChatCompletionAudioOutput$Outbound | undefined;
-};
-/** @internal */
-export declare const AssistantMessage$outboundSchema: z.ZodType<AssistantMessage$Outbound, AssistantMessage>;
-export declare function assistantMessageToJSON(assistantMessage: AssistantMessage): string;
-export declare function assistantMessageFromJSON(jsonString: string): SafeParseResult<AssistantMessage, SDKValidationError>;
-//# sourceMappingURL=assistantmessage.d.ts.map

package/esm/models/assistantmessage.js

@@ -1,86 +0,0 @@
-/*
- * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 2147a953e992
- */
-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 { ReasoningDetailUnion$inboundSchema, ReasoningDetailUnion$outboundSchema, } from "./reasoningdetailunion.js";
-export const AssistantMessageRole = {
-    Assistant: "assistant",
-};
-/** @internal */
-export const AssistantMessageRole$inboundSchema = z.enum(AssistantMessageRole);
-/** @internal */
-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));
-}
-export function assistantMessageContentFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => AssistantMessageContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AssistantMessageContent' from JSON`);
-}
-/** @internal */
-export const AssistantMessage$inboundSchema = z.object({
-    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(ReasoningDetailUnion$inboundSchema).optional(),
-    images: z.array(AssistantMessageImages$inboundSchema).optional(),
-    audio: ChatCompletionAudioOutput$inboundSchema.optional(),
-}).transform((v) => {
-    return remap$(v, {
-        "tool_calls": "toolCalls",
-        "reasoning_details": "reasoningDetails",
-    });
-});
-/** @internal */
-export const AssistantMessage$outboundSchema = z.object({
-    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(ReasoningDetailUnion$outboundSchema).optional(),
-    images: z.array(AssistantMessageImages$outboundSchema).optional(),
-    audio: ChatCompletionAudioOutput$outboundSchema.optional(),
-}).transform((v) => {
-    return remap$(v, {
-        toolCalls: "tool_calls",
-        reasoningDetails: "reasoning_details",
-    });
-});
-export function assistantMessageToJSON(assistantMessage) {
-    return JSON.stringify(AssistantMessage$outboundSchema.parse(assistantMessage));
-}
-export function assistantMessageFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => AssistantMessage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AssistantMessage' from JSON`);
-}
-//# sourceMappingURL=assistantmessage.js.map

package/esm/models/assistantmessageimages.d.ts

@@ -1,33 +0,0 @@
-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

@@ -1,44 +0,0 @@
-/*
- * 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.js

@@ -1,36 +0,0 @@
-/*
- * 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

package/esm/models/chatcompletionfinishreason.d.ts

@@ -1,13 +0,0 @@
-import * as z from "zod/v4";
-import { OpenEnum } from "../types/enums.js";
-export declare const ChatCompletionFinishReason: {
-    readonly ToolCalls: "tool_calls";
-    readonly Stop: "stop";
-    readonly Length: "length";
-    readonly ContentFilter: "content_filter";
-    readonly Error: "error";
-};
-export type ChatCompletionFinishReason = OpenEnum<typeof ChatCompletionFinishReason>;
-/** @internal */
-export declare const ChatCompletionFinishReason$inboundSchema: z.ZodType<ChatCompletionFinishReason, unknown>;
-//# sourceMappingURL=chatcompletionfinishreason.d.ts.map