@openrouter/sdk 0.10.2 → 0.12.0

package/esm/models/chatformatjsonschemaconfig.d.ts

@@ -0,0 +1,21 @@
+import * as z from "zod/v4";
+import { ChatJsonSchemaConfig, ChatJsonSchemaConfig$Outbound } from "./chatjsonschemaconfig.js";
+/**
+ * JSON Schema response format for structured outputs
+ */
+export type ChatFormatJsonSchemaConfig = {
+    /**
+     * JSON Schema configuration object
+     */
+    jsonSchema: ChatJsonSchemaConfig;
+    type: "json_schema";
+};
+/** @internal */
+export type ChatFormatJsonSchemaConfig$Outbound = {
+    json_schema: ChatJsonSchemaConfig$Outbound;
+    type: "json_schema";
+};
+/** @internal */
+export declare const ChatFormatJsonSchemaConfig$outboundSchema: z.ZodType<ChatFormatJsonSchemaConfig$Outbound, ChatFormatJsonSchemaConfig>;
+export declare function chatFormatJsonSchemaConfigToJSON(chatFormatJsonSchemaConfig: ChatFormatJsonSchemaConfig): string;
+//# sourceMappingURL=chatformatjsonschemaconfig.d.ts.map

package/esm/models/chatformatjsonschemaconfig.js

@@ -0,0 +1,20 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7e02597be9a9
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { ChatJsonSchemaConfig$outboundSchema, } from "./chatjsonschemaconfig.js";
+/** @internal */
+export const ChatFormatJsonSchemaConfig$outboundSchema = z.object({
+    jsonSchema: ChatJsonSchemaConfig$outboundSchema,
+    type: z.literal("json_schema"),
+}).transform((v) => {
+    return remap$(v, {
+        jsonSchema: "json_schema",
+    });
+});
+export function chatFormatJsonSchemaConfigToJSON(chatFormatJsonSchemaConfig) {
+    return JSON.stringify(ChatFormatJsonSchemaConfig$outboundSchema.parse(chatFormatJsonSchemaConfig));
+}
+//# sourceMappingURL=chatformatjsonschemaconfig.js.map

package/esm/models/chatformatpythonconfig.d.ts

@@ -0,0 +1,15 @@
+import * as z from "zod/v4";
+/**
+ * Python code response format
+ */
+export type ChatFormatPythonConfig = {
+    type: "python";
+};
+/** @internal */
+export type ChatFormatPythonConfig$Outbound = {
+    type: "python";
+};
+/** @internal */
+export declare const ChatFormatPythonConfig$outboundSchema: z.ZodType<ChatFormatPythonConfig$Outbound, ChatFormatPythonConfig>;
+export declare function chatFormatPythonConfigToJSON(chatFormatPythonConfig: ChatFormatPythonConfig): string;
+//# sourceMappingURL=chatformatpythonconfig.d.ts.map

package/esm/models/chatformatpythonconfig.js

@@ -0,0 +1,13 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7ba831befa19
+ */
+import * as z from "zod/v4";
+/** @internal */
+export const ChatFormatPythonConfig$outboundSchema = z.object({
+    type: z.literal("python"),
+});
+export function chatFormatPythonConfigToJSON(chatFormatPythonConfig) {
+    return JSON.stringify(ChatFormatPythonConfig$outboundSchema.parse(chatFormatPythonConfig));
+}
+//# sourceMappingURL=chatformatpythonconfig.js.map

package/esm/models/chatformattextconfig.d.ts

@@ -0,0 +1,15 @@
+import * as z from "zod/v4";
+/**
+ * Default text response format
+ */
+export type ChatFormatTextConfig = {
+    type: "text";
+};
+/** @internal */
+export type ChatFormatTextConfig$Outbound = {
+    type: "text";
+};
+/** @internal */
+export declare const ChatFormatTextConfig$outboundSchema: z.ZodType<ChatFormatTextConfig$Outbound, ChatFormatTextConfig>;
+export declare function chatFormatTextConfigToJSON(chatFormatTextConfig: ChatFormatTextConfig): string;
+//# sourceMappingURL=chatformattextconfig.d.ts.map

package/esm/models/chatformattextconfig.js

@@ -0,0 +1,13 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: cb7d0915102e
+ */
+import * as z from "zod/v4";
+/** @internal */
+export const ChatFormatTextConfig$outboundSchema = z.object({
+    type: z.literal("text"),
+});
+export function chatFormatTextConfigToJSON(chatFormatTextConfig) {
+    return JSON.stringify(ChatFormatTextConfig$outboundSchema.parse(chatFormatTextConfig));
+}
+//# sourceMappingURL=chatformattextconfig.js.map

package/esm/models/chatfunctiontool.d.ts

@@ -0,0 +1,77 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { ChatContentCacheControl, ChatContentCacheControl$Outbound } from "./chatcontentcachecontrol.js";
+import { ChatWebSearchShorthand, ChatWebSearchShorthand$Outbound } from "./chatwebsearchshorthand.js";
+import { DatetimeServerTool, DatetimeServerTool$Outbound } from "./datetimeservertool.js";
+import { OpenRouterWebSearchServerTool, OpenRouterWebSearchServerTool$Outbound } from "./openrouterwebsearchservertool.js";
+/**
+ * Function definition for tool calling
+ */
+export type ChatFunctionToolFunctionFunction = {
+    /**
+     * 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
+     */
+    parameters?: {
+        [k: string]: any | null;
+    } | undefined;
+    /**
+     * Enable strict schema adherence
+     */
+    strict?: boolean | null | undefined;
+};
+export declare const ChatFunctionToolType: {
+    readonly Function: "function";
+};
+export type ChatFunctionToolType = ClosedEnum<typeof ChatFunctionToolType>;
+export type ChatFunctionToolFunction = {
+    /**
+     * 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 | OpenRouterWebSearchServerTool | ChatWebSearchShorthand;
+/** @internal */
+export type ChatFunctionToolFunctionFunction$Outbound = {
+    description?: string | undefined;
+    name: string;
+    parameters?: {
+        [k: string]: any | null;
+    } | undefined;
+    strict?: boolean | null | undefined;
+};
+/** @internal */
+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 = {
+    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 | OpenRouterWebSearchServerTool$Outbound | ChatWebSearchShorthand$Outbound;
+/** @internal */
+export declare const ChatFunctionTool$outboundSchema: z.ZodType<ChatFunctionTool$Outbound, ChatFunctionTool>;
+export declare function chatFunctionToolToJSON(chatFunctionTool: ChatFunctionTool): string;
+//# sourceMappingURL=chatfunctiontool.d.ts.map

package/esm/models/chatfunctiontool.js

@@ -0,0 +1,49 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 400104319b29
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { ChatContentCacheControl$outboundSchema, } from "./chatcontentcachecontrol.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 ChatFunctionToolFunctionFunction$outboundSchema = z.object({
+    description: z.string().optional(),
+    name: z.string(),
+    parameters: z.record(z.string(), z.nullable(z.any())).optional(),
+    strict: z.nullable(z.boolean()).optional(),
+});
+export function chatFunctionToolFunctionFunctionToJSON(chatFunctionToolFunctionFunction) {
+    return JSON.stringify(ChatFunctionToolFunctionFunction$outboundSchema.parse(chatFunctionToolFunctionFunction));
+}
+/** @internal */
+export const ChatFunctionToolType$outboundSchema = z.enum(ChatFunctionToolType);
+/** @internal */
+export const ChatFunctionToolFunction$outboundSchema = z.object({
+    cacheControl: ChatContentCacheControl$outboundSchema.optional(),
+    function: z.lazy(() => ChatFunctionToolFunctionFunction$outboundSchema),
+    type: ChatFunctionToolType$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        cacheControl: "cache_control",
+    });
+});
+export function chatFunctionToolFunctionToJSON(chatFunctionToolFunction) {
+    return JSON.stringify(ChatFunctionToolFunction$outboundSchema.parse(chatFunctionToolFunction));
+}
+/** @internal */
+export const ChatFunctionTool$outboundSchema = z.union([
+    z.lazy(() => ChatFunctionToolFunction$outboundSchema),
+    DatetimeServerTool$outboundSchema,
+    OpenRouterWebSearchServerTool$outboundSchema,
+    ChatWebSearchShorthand$outboundSchema,
+]);
+export function chatFunctionToolToJSON(chatFunctionTool) {
+    return JSON.stringify(ChatFunctionTool$outboundSchema.parse(chatFunctionTool));
+}
+//# sourceMappingURL=chatfunctiontool.js.map

package/esm/models/{jsonschemaconfig.d.ts → chatjsonschemaconfig.d.ts}

@@ -2,15 +2,15 @@ import * as z from "zod/v4";
 /**
  * JSON Schema configuration object
  */
-export type JSONSchemaConfig = {
-    /**
-     * Schema name (a-z, A-Z, 0-9, underscores, dashes, max 64 chars)
-     */
-    name: string;
+export type ChatJsonSchemaConfig = {
     /**
      * 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
      */
@@ -23,15 +23,15 @@ export type JSONSchemaConfig = {
     strict?: boolean | null | undefined;
 };
 /** @internal */
-export type JSONSchemaConfig$Outbound = {
-    name: string;
+export type ChatJsonSchemaConfig$Outbound = {
     description?: string | undefined;
+    name: string;
     schema?: {
         [k: string]: any | null;
     } | undefined;
     strict?: boolean | null | undefined;
 };
 /** @internal */
-export declare const JSONSchemaConfig$outboundSchema: z.ZodType<JSONSchemaConfig$Outbound, JSONSchemaConfig>;
-export declare function jsonSchemaConfigToJSON(jsonSchemaConfig: JSONSchemaConfig): string;
-//# sourceMappingURL=jsonschemaconfig.d.ts.map
+export declare const ChatJsonSchemaConfig$outboundSchema: z.ZodType<ChatJsonSchemaConfig$Outbound, ChatJsonSchemaConfig>;
+export declare function chatJsonSchemaConfigToJSON(chatJsonSchemaConfig: ChatJsonSchemaConfig): string;
+//# sourceMappingURL=chatjsonschemaconfig.d.ts.map

package/esm/models/{jsonschemaconfig.js → chatjsonschemaconfig.js}

@@ -1,16 +1,16 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: a5dbdd0305ec
+ * @generated-id: 1ad0e5d930fb
  */
 import * as z from "zod/v4";
 /** @internal */
-export const JSONSchemaConfig$outboundSchema = z.object({
-    name: z.string(),
+export const ChatJsonSchemaConfig$outboundSchema = z.object({
     description: z.string().optional(),
+    name: z.string(),
     schema: z.record(z.string(), z.nullable(z.any())).optional(),
     strict: z.nullable(z.boolean()).optional(),
 });
-export function jsonSchemaConfigToJSON(jsonSchemaConfig) {
-    return JSON.stringify(JSONSchemaConfig$outboundSchema.parse(jsonSchemaConfig));
+export function chatJsonSchemaConfigToJSON(chatJsonSchemaConfig) {
+    return JSON.stringify(ChatJsonSchemaConfig$outboundSchema.parse(chatJsonSchemaConfig));
 }
-//# sourceMappingURL=jsonschemaconfig.js.map
+//# sourceMappingURL=chatjsonschemaconfig.js.map

package/esm/models/chatmessages.d.ts

@@ -0,0 +1,20 @@
+import * as z from "zod/v4";
+import { ChatAssistantMessage, ChatAssistantMessage$Outbound } from "./chatassistantmessage.js";
+import { ChatDeveloperMessage, ChatDeveloperMessage$Outbound } from "./chatdevelopermessage.js";
+import { ChatSystemMessage, ChatSystemMessage$Outbound } from "./chatsystemmessage.js";
+import { ChatToolMessage, ChatToolMessage$Outbound } from "./chattoolmessage.js";
+import { ChatUserMessage, ChatUserMessage$Outbound } from "./chatusermessage.js";
+/**
+ * Chat completion message with role-based discrimination
+ */
+export type ChatMessages = (ChatAssistantMessage & {
+    role: "assistant";
+}) | ChatDeveloperMessage | ChatSystemMessage | ChatToolMessage | ChatUserMessage;
+/** @internal */
+export type ChatMessages$Outbound = (ChatAssistantMessage$Outbound & {
+    role: "assistant";
+}) | 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;
+//# sourceMappingURL=chatmessages.d.ts.map

package/esm/models/chatmessages.js

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: f21e02796127
+ */
+import * as z from "zod/v4";
+import { ChatAssistantMessage$outboundSchema, } from "./chatassistantmessage.js";
+import { ChatDeveloperMessage$outboundSchema, } from "./chatdevelopermessage.js";
+import { ChatSystemMessage$outboundSchema, } from "./chatsystemmessage.js";
+import { ChatToolMessage$outboundSchema, } from "./chattoolmessage.js";
+import { ChatUserMessage$outboundSchema, } from "./chatusermessage.js";
+/** @internal */
+export const ChatMessages$outboundSchema = z.union([
+    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));
+}
+//# sourceMappingURL=chatmessages.js.map

package/esm/models/chatnamedtoolchoice.d.ts

@@ -0,0 +1,37 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+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 = {
+    function: ChatNamedToolChoiceFunction;
+    type: ChatNamedToolChoiceType;
+};
+/** @internal */
+export type ChatNamedToolChoiceFunction$Outbound = {
+    name: string;
+};
+/** @internal */
+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 = {
+    function: ChatNamedToolChoiceFunction$Outbound;
+    type: string;
+};
+/** @internal */
+export declare const ChatNamedToolChoice$outboundSchema: z.ZodType<ChatNamedToolChoice$Outbound, ChatNamedToolChoice>;
+export declare function chatNamedToolChoiceToJSON(chatNamedToolChoice: ChatNamedToolChoice): string;
+//# sourceMappingURL=chatnamedtoolchoice.d.ts.map

package/esm/models/chatnamedtoolchoice.js

@@ -0,0 +1,26 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: bc876a8e64eb
+ */
+import * as z from "zod/v4";
+export const ChatNamedToolChoiceType = {
+    Function: "function",
+};
+/** @internal */
+export const ChatNamedToolChoiceFunction$outboundSchema = z.object({
+    name: z.string(),
+});
+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({
+    function: z.lazy(() => ChatNamedToolChoiceFunction$outboundSchema),
+    type: ChatNamedToolChoiceType$outboundSchema,
+});
+export function chatNamedToolChoiceToJSON(chatNamedToolChoice) {
+    return JSON.stringify(ChatNamedToolChoice$outboundSchema.parse(chatNamedToolChoice));
+}
+//# sourceMappingURL=chatnamedtoolchoice.js.map

package/esm/models/chatreasoningsummaryverbosityenum.d.ts

@@ -0,0 +1,11 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+export declare const ChatReasoningSummaryVerbosityEnum: {
+    readonly Auto: "auto";
+    readonly Concise: "concise";
+    readonly Detailed: "detailed";
+};
+export type ChatReasoningSummaryVerbosityEnum = OpenEnum<typeof ChatReasoningSummaryVerbosityEnum>;
+/** @internal */
+export declare const ChatReasoningSummaryVerbosityEnum$outboundSchema: z.ZodType<string, ChatReasoningSummaryVerbosityEnum>;
+//# sourceMappingURL=chatreasoningsummaryverbosityenum.d.ts.map

package/esm/models/chatreasoningsummaryverbosityenum.js

@@ -0,0 +1,13 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: b688b538e122
+ */
+import * as openEnums from "../types/enums.js";
+export const ChatReasoningSummaryVerbosityEnum = {
+    Auto: "auto",
+    Concise: "concise",
+    Detailed: "detailed",
+};
+/** @internal */
+export const ChatReasoningSummaryVerbosityEnum$outboundSchema = openEnums.outboundSchema(ChatReasoningSummaryVerbosityEnum);
+//# sourceMappingURL=chatreasoningsummaryverbosityenum.js.map