@openrouter/sdk 0.9.11 → 0.11.2

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 { ChatWebSearchServerTool, ChatWebSearchServerTool$Outbound } from "./chatwebsearchservertool.js";
+import { ChatWebSearchShorthand, ChatWebSearchShorthand$Outbound } from "./chatwebsearchshorthand.js";
+import { DatetimeServerTool, DatetimeServerTool$Outbound } from "./datetimeservertool.js";
+export declare const ChatFunctionToolType: {
+    readonly Function: "function";
+};
+export type ChatFunctionToolType = ClosedEnum<typeof ChatFunctionToolType>;
+/**
+ * Function definition for tool calling
+ */
+export type ChatFunctionToolFunctionFunction = {
+    /**
+     * Function name (a-z, A-Z, 0-9, underscores, dashes, max 64 chars)
+     */
+    name: string;
+    /**
+     * Function description for the model
+     */
+    description?: string | undefined;
+    /**
+     * Function parameters as JSON Schema object
+     */
+    parameters?: {
+        [k: string]: any | null;
+    } | undefined;
+    /**
+     * Enable strict schema adherence
+     */
+    strict?: boolean | null | undefined;
+};
+export type ChatFunctionToolFunction = {
+    type: ChatFunctionToolType;
+    /**
+     * Function definition for tool calling
+     */
+    function: ChatFunctionToolFunctionFunction;
+    /**
+     * Cache control for the content part
+     */
+    cacheControl?: ChatContentCacheControl | undefined;
+};
+/**
+ * Tool definition for function calling (regular function or OpenRouter built-in server tool)
+ */
+export type ChatFunctionTool = ChatFunctionToolFunction | DatetimeServerTool | ChatWebSearchServerTool | ChatWebSearchShorthand;
+/** @internal */
+export declare const ChatFunctionToolType$outboundSchema: z.ZodEnum<typeof ChatFunctionToolType>;
+/** @internal */
+export type ChatFunctionToolFunctionFunction$Outbound = {
+    name: string;
+    description?: string | undefined;
+    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 type ChatFunctionToolFunction$Outbound = {
+    type: string;
+    function: ChatFunctionToolFunctionFunction$Outbound;
+    cache_control?: ChatContentCacheControl$Outbound | undefined;
+};
+/** @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 | ChatWebSearchServerTool$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 { ChatWebSearchServerTool$outboundSchema, } from "./chatwebsearchservertool.js";
+import { ChatWebSearchShorthand$outboundSchema, } from "./chatwebsearchshorthand.js";
+import { DatetimeServerTool$outboundSchema, } from "./datetimeservertool.js";
+export const ChatFunctionToolType = {
+    Function: "function",
+};
+/** @internal */
+export const ChatFunctionToolType$outboundSchema = z.enum(ChatFunctionToolType);
+/** @internal */
+export const ChatFunctionToolFunctionFunction$outboundSchema = z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    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 ChatFunctionToolFunction$outboundSchema = z.object({
+    type: ChatFunctionToolType$outboundSchema,
+    function: z.lazy(() => ChatFunctionToolFunctionFunction$outboundSchema),
+    cacheControl: ChatContentCacheControl$outboundSchema.optional(),
+}).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,
+    ChatWebSearchServerTool$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,7 +2,7 @@ import * as z from "zod/v4";
 /**
  * JSON Schema configuration object
  */
-export type JSONSchemaConfig = {
+export type ChatJsonSchemaConfig = {
     /**
      * Schema name (a-z, A-Z, 0-9, underscores, dashes, max 64 chars)
      */
@@ -23,7 +23,7 @@ export type JSONSchemaConfig = {
     strict?: boolean | null | undefined;
 };
 /** @internal */
-export type JSONSchemaConfig$Outbound = {
+export type ChatJsonSchemaConfig$Outbound = {
     name: string;
     description?: string | undefined;
     schema?: {
@@ -32,6 +32,6 @@ export type JSONSchemaConfig$Outbound = {
     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({
+export const ChatJsonSchemaConfig$outboundSchema = z.object({
     name: z.string(),
     description: z.string().optional(),
     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 = ChatSystemMessage | ChatUserMessage | ChatDeveloperMessage | (ChatAssistantMessage & {
+    role: "assistant";
+}) | ChatToolMessage;
+/** @internal */
+export type ChatMessages$Outbound = ChatSystemMessage$Outbound | ChatUserMessage$Outbound | ChatDeveloperMessage$Outbound | (ChatAssistantMessage$Outbound & {
+    role: "assistant";
+}) | ChatToolMessage$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([
+    ChatSystemMessage$outboundSchema,
+    ChatUserMessage$outboundSchema,
+    ChatDeveloperMessage$outboundSchema,
+    ChatAssistantMessage$outboundSchema.and(z.object({ role: z.literal("assistant") })),
+    ChatToolMessage$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 declare const ChatNamedToolChoiceType: {
+    readonly Function: "function";
+};
+export type ChatNamedToolChoiceType = ClosedEnum<typeof ChatNamedToolChoiceType>;
+export type ChatNamedToolChoiceFunction = {
+    /**
+     * Function name to call
+     */
+    name: string;
+};
+/**
+ * Named tool choice for specific function
+ */
+export type ChatNamedToolChoice = {
+    type: ChatNamedToolChoiceType;
+    function: ChatNamedToolChoiceFunction;
+};
+/** @internal */
+export declare const ChatNamedToolChoiceType$outboundSchema: z.ZodEnum<typeof 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 type ChatNamedToolChoice$Outbound = {
+    type: string;
+    function: ChatNamedToolChoiceFunction$Outbound;
+};
+/** @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 ChatNamedToolChoiceType$outboundSchema = z.enum(ChatNamedToolChoiceType);
+/** @internal */
+export const ChatNamedToolChoiceFunction$outboundSchema = z.object({
+    name: z.string(),
+});
+export function chatNamedToolChoiceFunctionToJSON(chatNamedToolChoiceFunction) {
+    return JSON.stringify(ChatNamedToolChoiceFunction$outboundSchema.parse(chatNamedToolChoiceFunction));
+}
+/** @internal */
+export const ChatNamedToolChoice$outboundSchema = z.object({
+    type: ChatNamedToolChoiceType$outboundSchema,
+    function: z.lazy(() => ChatNamedToolChoiceFunction$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