@openrouter/sdk 0.11.2 → 0.12.0

package/esm/models/contentpartaddedevent.js

@@ -5,35 +5,36 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
 import { OpenAIResponsesRefusalContent$inboundSchema, } from "./openairesponsesrefusalcontent.js";
 import { ReasoningTextContent$inboundSchema, } from "./reasoningtextcontent.js";
 import { ResponseOutputText$inboundSchema, } from "./responseoutputtext.js";
 /** @internal */
-export const ContentPartAddedEventPart$inboundSchema = z.union([
-    ResponseOutputText$inboundSchema,
-    ReasoningTextContent$inboundSchema.and(z.object({ type: z.literal("reasoning_text") })),
-    OpenAIResponsesRefusalContent$inboundSchema,
-]);
+export const ContentPartAddedEventPart$inboundSchema = discriminatedUnion("type", {
+    output_text: ResponseOutputText$inboundSchema,
+    reasoning_text: ReasoningTextContent$inboundSchema.and(z.object({ type: z.literal("reasoning_text") })),
+    refusal: OpenAIResponsesRefusalContent$inboundSchema,
+});
 export function contentPartAddedEventPartFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ContentPartAddedEventPart$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ContentPartAddedEventPart' from JSON`);
 }
 /** @internal */
 export const ContentPartAddedEvent$inboundSchema = z.object({
-    type: z.literal("response.content_part.added"),
-    output_index: z.number(),
+    content_index: z.int(),
     item_id: z.string(),
-    content_index: z.number(),
-    part: z.union([
-        ResponseOutputText$inboundSchema,
-        ReasoningTextContent$inboundSchema.and(z.object({ type: z.literal("reasoning_text") })),
-        OpenAIResponsesRefusalContent$inboundSchema,
-    ]),
-    sequence_number: z.number(),
+    output_index: z.int(),
+    part: discriminatedUnion("type", {
+        output_text: ResponseOutputText$inboundSchema,
+        reasoning_text: ReasoningTextContent$inboundSchema.and(z.object({ type: z.literal("reasoning_text") })),
+        refusal: OpenAIResponsesRefusalContent$inboundSchema,
+    }),
+    sequence_number: z.int(),
+    type: z.literal("response.content_part.added"),
 }).transform((v) => {
     return remap$(v, {
-        "output_index": "outputIndex",
-        "item_id": "itemId",
         "content_index": "contentIndex",
+        "item_id": "itemId",
+        "output_index": "outputIndex",
         "sequence_number": "sequenceNumber",
     });
 });

package/esm/models/contentpartdoneevent.d.ts

@@ -1,4 +1,5 @@
 import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { OpenAIResponsesRefusalContent } from "./openairesponsesrefusalcontent.js";
@@ -6,19 +7,19 @@ import { ReasoningTextContent } from "./reasoningtextcontent.js";
 import { ResponseOutputText } from "./responseoutputtext.js";
 export type ContentPartDoneEventPart = ResponseOutputText | (ReasoningTextContent & {
     type: "reasoning_text";
-}) | OpenAIResponsesRefusalContent;
+}) | OpenAIResponsesRefusalContent | discriminatedUnionTypes.Unknown<"type">;
 /**
  * Event emitted when a content part is complete
  */
 export type ContentPartDoneEvent = {
-    type: "response.content_part.done";
-    outputIndex: number;
-    itemId: string;
     contentIndex: number;
+    itemId: string;
+    outputIndex: number;
     part: ResponseOutputText | (ReasoningTextContent & {
         type: "reasoning_text";
-    }) | OpenAIResponsesRefusalContent;
+    }) | OpenAIResponsesRefusalContent | discriminatedUnionTypes.Unknown<"type">;
     sequenceNumber: number;
+    type: "response.content_part.done";
 };
 /** @internal */
 export declare const ContentPartDoneEventPart$inboundSchema: z.ZodType<ContentPartDoneEventPart, unknown>;

package/esm/models/contentpartdoneevent.js

@@ -5,35 +5,36 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
 import { OpenAIResponsesRefusalContent$inboundSchema, } from "./openairesponsesrefusalcontent.js";
 import { ReasoningTextContent$inboundSchema, } from "./reasoningtextcontent.js";
 import { ResponseOutputText$inboundSchema, } from "./responseoutputtext.js";
 /** @internal */
-export const ContentPartDoneEventPart$inboundSchema = z.union([
-    ResponseOutputText$inboundSchema,
-    ReasoningTextContent$inboundSchema.and(z.object({ type: z.literal("reasoning_text") })),
-    OpenAIResponsesRefusalContent$inboundSchema,
-]);
+export const ContentPartDoneEventPart$inboundSchema = discriminatedUnion("type", {
+    output_text: ResponseOutputText$inboundSchema,
+    reasoning_text: ReasoningTextContent$inboundSchema.and(z.object({ type: z.literal("reasoning_text") })),
+    refusal: OpenAIResponsesRefusalContent$inboundSchema,
+});
 export function contentPartDoneEventPartFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ContentPartDoneEventPart$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ContentPartDoneEventPart' from JSON`);
 }
 /** @internal */
 export const ContentPartDoneEvent$inboundSchema = z.object({
-    type: z.literal("response.content_part.done"),
-    output_index: z.number(),
+    content_index: z.int(),
     item_id: z.string(),
-    content_index: z.number(),
-    part: z.union([
-        ResponseOutputText$inboundSchema,
-        ReasoningTextContent$inboundSchema.and(z.object({ type: z.literal("reasoning_text") })),
-        OpenAIResponsesRefusalContent$inboundSchema,
-    ]),
-    sequence_number: z.number(),
+    output_index: z.int(),
+    part: discriminatedUnion("type", {
+        output_text: ResponseOutputText$inboundSchema,
+        reasoning_text: ReasoningTextContent$inboundSchema.and(z.object({ type: z.literal("reasoning_text") })),
+        refusal: OpenAIResponsesRefusalContent$inboundSchema,
+    }),
+    sequence_number: z.int(),
+    type: z.literal("response.content_part.done"),
 }).transform((v) => {
     return remap$(v, {
-        "output_index": "outputIndex",
-        "item_id": "itemId",
         "content_index": "contentIndex",
+        "item_id": "itemId",
+        "output_index": "outputIndex",
         "sequence_number": "sequenceNumber",
     });
 });

package/esm/models/contentpartimage.d.ts

@@ -0,0 +1,31 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+export type ContentPartImageImageUrl = {
+    url: string;
+};
+export declare const ContentPartImageType: {
+    readonly ImageUrl: "image_url";
+};
+export type ContentPartImageType = ClosedEnum<typeof ContentPartImageType>;
+export type ContentPartImage = {
+    imageUrl: ContentPartImageImageUrl;
+    type: ContentPartImageType;
+};
+/** @internal */
+export type ContentPartImageImageUrl$Outbound = {
+    url: string;
+};
+/** @internal */
+export declare const ContentPartImageImageUrl$outboundSchema: z.ZodType<ContentPartImageImageUrl$Outbound, ContentPartImageImageUrl>;
+export declare function contentPartImageImageUrlToJSON(contentPartImageImageUrl: ContentPartImageImageUrl): string;
+/** @internal */
+export declare const ContentPartImageType$outboundSchema: z.ZodEnum<typeof ContentPartImageType>;
+/** @internal */
+export type ContentPartImage$Outbound = {
+    image_url: ContentPartImageImageUrl$Outbound;
+    type: string;
+};
+/** @internal */
+export declare const ContentPartImage$outboundSchema: z.ZodType<ContentPartImage$Outbound, ContentPartImage>;
+export declare function contentPartImageToJSON(contentPartImage: ContentPartImage): string;
+//# sourceMappingURL=contentpartimage.d.ts.map

package/esm/models/contentpartimage.js

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 6b4d72ed5ae8
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+export const ContentPartImageType = {
+    ImageUrl: "image_url",
+};
+/** @internal */
+export const ContentPartImageImageUrl$outboundSchema = z.object({
+    url: z.string(),
+});
+export function contentPartImageImageUrlToJSON(contentPartImageImageUrl) {
+    return JSON.stringify(ContentPartImageImageUrl$outboundSchema.parse(contentPartImageImageUrl));
+}
+/** @internal */
+export const ContentPartImageType$outboundSchema = z.enum(ContentPartImageType);
+/** @internal */
+export const ContentPartImage$outboundSchema = z.object({
+    imageUrl: z.lazy(() => ContentPartImageImageUrl$outboundSchema),
+    type: ContentPartImageType$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        imageUrl: "image_url",
+    });
+});
+export function contentPartImageToJSON(contentPartImage) {
+    return JSON.stringify(ContentPartImage$outboundSchema.parse(contentPartImage));
+}
+//# sourceMappingURL=contentpartimage.js.map

package/esm/models/contextcompressionplugin.d.ts

@@ -0,0 +1,23 @@
+import * as z from "zod/v4";
+import { ContextCompressionEngine } from "./contextcompressionengine.js";
+export type ContextCompressionPlugin = {
+    /**
+     * Set to false to disable the context-compression plugin for this request. Defaults to true.
+     */
+    enabled?: boolean | undefined;
+    /**
+     * The compression engine to use. Defaults to "middle-out".
+     */
+    engine?: ContextCompressionEngine | undefined;
+    id: "context-compression";
+};
+/** @internal */
+export type ContextCompressionPlugin$Outbound = {
+    enabled?: boolean | undefined;
+    engine?: string | undefined;
+    id: "context-compression";
+};
+/** @internal */
+export declare const ContextCompressionPlugin$outboundSchema: z.ZodType<ContextCompressionPlugin$Outbound, ContextCompressionPlugin>;
+export declare function contextCompressionPluginToJSON(contextCompressionPlugin: ContextCompressionPlugin): string;
+//# sourceMappingURL=contextcompressionplugin.d.ts.map

package/esm/models/contextcompressionplugin.js

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e3e073b472a1
+ */
+import * as z from "zod/v4";
+import { ContextCompressionEngine$outboundSchema, } from "./contextcompressionengine.js";
+/** @internal */
+export const ContextCompressionPlugin$outboundSchema = z.object({
+    enabled: z.boolean().optional(),
+    engine: ContextCompressionEngine$outboundSchema.optional(),
+    id: z.literal("context-compression"),
+});
+export function contextCompressionPluginToJSON(contextCompressionPlugin) {
+    return JSON.stringify(ContextCompressionPlugin$outboundSchema.parse(contextCompressionPlugin));
+}
+//# sourceMappingURL=contextcompressionplugin.js.map

package/esm/models/createguardrailrequest.d.ts

@@ -0,0 +1,51 @@
+import * as z from "zod/v4";
+import { GuardrailInterval } from "./guardrailinterval.js";
+export type CreateGuardrailRequest = {
+    /**
+     * Array of model identifiers (slug or canonical_slug accepted)
+     */
+    allowedModels?: Array<string> | null | undefined;
+    /**
+     * List of allowed provider IDs
+     */
+    allowedProviders?: Array<string> | null | undefined;
+    /**
+     * Description of the guardrail
+     */
+    description?: string | null | undefined;
+    /**
+     * Whether to enforce zero data retention
+     */
+    enforceZdr?: boolean | null | undefined;
+    /**
+     * List of provider IDs to exclude from routing
+     */
+    ignoredProviders?: Array<string> | null | undefined;
+    /**
+     * Spending limit in USD
+     */
+    limitUsd?: number | undefined;
+    /**
+     * Name for the new guardrail
+     */
+    name: string;
+    /**
+     * Interval at which the limit resets (daily, weekly, monthly)
+     */
+    resetInterval?: GuardrailInterval | null | undefined;
+};
+/** @internal */
+export type CreateGuardrailRequest$Outbound = {
+    allowed_models?: Array<string> | null | undefined;
+    allowed_providers?: Array<string> | null | undefined;
+    description?: string | null | undefined;
+    enforce_zdr?: boolean | null | undefined;
+    ignored_providers?: Array<string> | null | undefined;
+    limit_usd?: number | undefined;
+    name: string;
+    reset_interval?: string | null | undefined;
+};
+/** @internal */
+export declare const CreateGuardrailRequest$outboundSchema: z.ZodType<CreateGuardrailRequest$Outbound, CreateGuardrailRequest>;
+export declare function createGuardrailRequestToJSON(createGuardrailRequest: CreateGuardrailRequest): string;
+//# sourceMappingURL=createguardrailrequest.d.ts.map

package/esm/models/createguardrailrequest.js

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: fbf07f1435fd
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { GuardrailInterval$outboundSchema, } from "./guardrailinterval.js";
+/** @internal */
+export const CreateGuardrailRequest$outboundSchema = z.object({
+    allowedModels: z.nullable(z.array(z.string())).optional(),
+    allowedProviders: z.nullable(z.array(z.string())).optional(),
+    description: z.nullable(z.string()).optional(),
+    enforceZdr: z.nullable(z.boolean()).optional(),
+    ignoredProviders: z.nullable(z.array(z.string())).optional(),
+    limitUsd: z.number().optional(),
+    name: z.string(),
+    resetInterval: z.nullable(GuardrailInterval$outboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        allowedModels: "allowed_models",
+        allowedProviders: "allowed_providers",
+        enforceZdr: "enforce_zdr",
+        ignoredProviders: "ignored_providers",
+        limitUsd: "limit_usd",
+        resetInterval: "reset_interval",
+    });
+});
+export function createGuardrailRequestToJSON(createGuardrailRequest) {
+    return JSON.stringify(CreateGuardrailRequest$outboundSchema.parse(createGuardrailRequest));
+}
+//# sourceMappingURL=createguardrailrequest.js.map

package/esm/models/createguardrailresponse.d.ts

@@ -0,0 +1,11 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { Guardrail } from "./guardrail.js";
+export type CreateGuardrailResponse = {
+    data: Guardrail;
+};
+/** @internal */
+export declare const CreateGuardrailResponse$inboundSchema: z.ZodType<CreateGuardrailResponse, unknown>;
+export declare function createGuardrailResponseFromJSON(jsonString: string): SafeParseResult<CreateGuardrailResponse, SDKValidationError>;
+//# sourceMappingURL=createguardrailresponse.d.ts.map

package/esm/models/createguardrailresponse.js

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: f0b6f29656b5
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { Guardrail$inboundSchema } from "./guardrail.js";
+/** @internal */
+export const CreateGuardrailResponse$inboundSchema = z.object({
+    data: Guardrail$inboundSchema,
+});
+export function createGuardrailResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CreateGuardrailResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateGuardrailResponse' from JSON`);
+}
+//# sourceMappingURL=createguardrailresponse.js.map

package/esm/models/customtool.d.ts

@@ -1,4 +1,5 @@
 import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
 import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
@@ -8,22 +9,22 @@ export declare const Syntax: {
 };
 export type Syntax = OpenEnum<typeof Syntax>;
 export type FormatGrammar = {
-    type: "grammar";
     definition: string;
     syntax: Syntax;
+    type: "grammar";
 };
 export type FormatText = {
     type: "text";
 };
-export type Format = FormatText | FormatGrammar;
+export type Format = FormatText | FormatGrammar | discriminatedUnionTypes.Unknown<"type">;
 /**
  * Custom tool configuration
  */
 export type CustomTool = {
-    type: "custom";
-    name: string;
     description?: string | undefined;
-    format?: FormatText | FormatGrammar | undefined;
+    format?: FormatText | FormatGrammar | discriminatedUnionTypes.Unknown<"type"> | undefined;
+    name: string;
+    type: "custom";
 };
 /** @internal */
 export declare const Syntax$inboundSchema: z.ZodType<Syntax, unknown>;
@@ -33,9 +34,9 @@ export declare const Syntax$outboundSchema: z.ZodType<string, Syntax>;
 export declare const FormatGrammar$inboundSchema: z.ZodType<FormatGrammar, unknown>;
 /** @internal */
 export type FormatGrammar$Outbound = {
-    type: "grammar";
     definition: string;
     syntax: string;
+    type: "grammar";
 };
 /** @internal */
 export declare const FormatGrammar$outboundSchema: z.ZodType<FormatGrammar$Outbound, FormatGrammar>;
@@ -63,10 +64,10 @@ export declare function formatFromJSON(jsonString: string): SafeParseResult<Form
 export declare const CustomTool$inboundSchema: z.ZodType<CustomTool, unknown>;
 /** @internal */
 export type CustomTool$Outbound = {
-    type: "custom";
-    name: string;
     description?: string | undefined;
     format?: FormatText$Outbound | FormatGrammar$Outbound | undefined;
+    name: string;
+    type: "custom";
 };
 /** @internal */
 export declare const CustomTool$outboundSchema: z.ZodType<CustomTool$Outbound, CustomTool>;

package/esm/models/customtool.js

@@ -4,6 +4,7 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
 import * as openEnums from "../types/enums.js";
 export const Syntax = {
     Lark: "lark",
@@ -18,15 +19,15 @@ export const Syntax$outboundSchema = openEnums
 /** @internal */
 export const FormatGrammar$inboundSchema = z
     .object({
-    type: z.literal("grammar"),
     definition: z.string(),
     syntax: Syntax$inboundSchema,
+    type: z.literal("grammar"),
 });
 /** @internal */
 export const FormatGrammar$outboundSchema = z.object({
-    type: z.literal("grammar"),
     definition: z.string(),
     syntax: Syntax$outboundSchema,
+    type: z.literal("grammar"),
 });
 export function formatGrammarToJSON(formatGrammar) {
     return JSON.stringify(FormatGrammar$outboundSchema.parse(formatGrammar));
@@ -50,10 +51,10 @@ export function formatTextFromJSON(jsonString) {
     return safeParse(jsonString, (x) => FormatText$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FormatText' from JSON`);
 }
 /** @internal */
-export const Format$inboundSchema = z.union([
-    z.lazy(() => FormatText$inboundSchema),
-    z.lazy(() => FormatGrammar$inboundSchema),
-]);
+export const Format$inboundSchema = discriminatedUnion("type", {
+    text: z.lazy(() => FormatText$inboundSchema),
+    grammar: z.lazy(() => FormatGrammar$inboundSchema),
+});
 /** @internal */
 export const Format$outboundSchema = z
     .union([
@@ -69,23 +70,23 @@ export function formatFromJSON(jsonString) {
 /** @internal */
 export const CustomTool$inboundSchema = z
     .object({
-    type: z.literal("custom"),
-    name: z.string(),
     description: z.string().optional(),
-    format: z.union([
-        z.lazy(() => FormatText$inboundSchema),
-        z.lazy(() => FormatGrammar$inboundSchema),
-    ]).optional(),
+    format: discriminatedUnion("type", {
+        text: z.lazy(() => FormatText$inboundSchema),
+        grammar: z.lazy(() => FormatGrammar$inboundSchema),
+    }).optional(),
+    name: z.string(),
+    type: z.literal("custom"),
 });
 /** @internal */
 export const CustomTool$outboundSchema = z.object({
-    type: z.literal("custom"),
-    name: z.string(),
     description: z.string().optional(),
     format: z.union([
         z.lazy(() => FormatText$outboundSchema),
         z.lazy(() => FormatGrammar$outboundSchema),
     ]).optional(),
+    name: z.string(),
+    type: z.literal("custom"),
 });
 export function customToolToJSON(customTool) {
     return JSON.stringify(CustomTool$outboundSchema.parse(customTool));

package/esm/models/datetimeservertool.d.ts

@@ -1,35 +1,26 @@
 import * as z from "zod/v4";
 import { ClosedEnum } from "../types/enums.js";
+import { DatetimeServerToolConfig, DatetimeServerToolConfig$Outbound } from "./datetimeservertoolconfig.js";
 export declare const DatetimeServerToolType: {
     readonly OpenrouterDatetime: "openrouter:datetime";
 };
 export type DatetimeServerToolType = ClosedEnum<typeof DatetimeServerToolType>;
-export type DatetimeServerToolParameters = {
-    /**
-     * IANA timezone name (e.g. "America/New_York"). Defaults to UTC.
-     */
-    timezone?: string | undefined;
-};
 /**
  * OpenRouter built-in server tool: returns the current date and time
  */
 export type DatetimeServerTool = {
+    /**
+     * Configuration for the openrouter:datetime server tool
+     */
+    parameters?: DatetimeServerToolConfig | undefined;
     type: DatetimeServerToolType;
-    parameters?: DatetimeServerToolParameters | undefined;
 };
 /** @internal */
 export declare const DatetimeServerToolType$outboundSchema: z.ZodEnum<typeof DatetimeServerToolType>;
 /** @internal */
-export type DatetimeServerToolParameters$Outbound = {
-    timezone?: string | undefined;
-};
-/** @internal */
-export declare const DatetimeServerToolParameters$outboundSchema: z.ZodType<DatetimeServerToolParameters$Outbound, DatetimeServerToolParameters>;
-export declare function datetimeServerToolParametersToJSON(datetimeServerToolParameters: DatetimeServerToolParameters): string;
-/** @internal */
 export type DatetimeServerTool$Outbound = {
+    parameters?: DatetimeServerToolConfig$Outbound | undefined;
     type: string;
-    parameters?: DatetimeServerToolParameters$Outbound | undefined;
 };
 /** @internal */
 export declare const DatetimeServerTool$outboundSchema: z.ZodType<DatetimeServerTool$Outbound, DatetimeServerTool>;

package/esm/models/datetimeservertool.js

@@ -3,23 +3,16 @@
  * @generated-id: e4d8b08fcbb5
  */
 import * as z from "zod/v4";
+import { DatetimeServerToolConfig$outboundSchema, } from "./datetimeservertoolconfig.js";
 export const DatetimeServerToolType = {
     OpenrouterDatetime: "openrouter:datetime",
 };
 /** @internal */
 export const DatetimeServerToolType$outboundSchema = z.enum(DatetimeServerToolType);
 /** @internal */
-export const DatetimeServerToolParameters$outboundSchema = z.object({
-    timezone: z.string().optional(),
-});
-export function datetimeServerToolParametersToJSON(datetimeServerToolParameters) {
-    return JSON.stringify(DatetimeServerToolParameters$outboundSchema.parse(datetimeServerToolParameters));
-}
-/** @internal */
 export const DatetimeServerTool$outboundSchema = z.object({
+    parameters: DatetimeServerToolConfig$outboundSchema.optional(),
     type: DatetimeServerToolType$outboundSchema,
-    parameters: z.lazy(() => DatetimeServerToolParameters$outboundSchema)
-        .optional(),
 });
 export function datetimeServerToolToJSON(datetimeServerTool) {
     return JSON.stringify(DatetimeServerTool$outboundSchema.parse(datetimeServerTool));

package/esm/models/datetimeservertoolconfig.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod/v4";
+/**
+ * Configuration for the openrouter:datetime server tool
+ */
+export type DatetimeServerToolConfig = {
+    /**
+     * IANA timezone name (e.g. "America/New_York"). Defaults to UTC.
+     */
+    timezone?: string | undefined;
+};
+/** @internal */
+export type DatetimeServerToolConfig$Outbound = {
+    timezone?: string | undefined;
+};
+/** @internal */
+export declare const DatetimeServerToolConfig$outboundSchema: z.ZodType<DatetimeServerToolConfig$Outbound, DatetimeServerToolConfig>;
+export declare function datetimeServerToolConfigToJSON(datetimeServerToolConfig: DatetimeServerToolConfig): string;
+//# sourceMappingURL=datetimeservertoolconfig.d.ts.map

package/esm/models/datetimeservertoolconfig.js

@@ -0,0 +1,13 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e0faf7e437d1
+ */
+import * as z from "zod/v4";
+/** @internal */
+export const DatetimeServerToolConfig$outboundSchema = z.object({
+    timezone: z.string().optional(),
+});
+export function datetimeServerToolConfigToJSON(datetimeServerToolConfig) {
+    return JSON.stringify(DatetimeServerToolConfig$outboundSchema.parse(datetimeServerToolConfig));
+}
+//# sourceMappingURL=datetimeservertoolconfig.js.map

package/esm/models/defaultparameters.d.ts

@@ -5,12 +5,12 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  * Default parameters for this model
  */
 export type DefaultParameters = {
-    temperature?: number | null | undefined;
-    topP?: number | null | undefined;
-    topK?: number | null | undefined;
     frequencyPenalty?: number | null | undefined;
     presencePenalty?: number | null | undefined;
     repetitionPenalty?: number | null | undefined;
+    temperature?: number | null | undefined;
+    topK?: number | null | undefined;
+    topP?: number | null | undefined;
 };
 /** @internal */
 export declare const DefaultParameters$inboundSchema: z.ZodType<DefaultParameters, unknown>;

package/esm/models/defaultparameters.js

@@ -7,19 +7,19 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const DefaultParameters$inboundSchema = z.object({
-    temperature: z.nullable(z.number()).optional(),
-    top_p: z.nullable(z.number()).optional(),
-    top_k: z.nullable(z.int()).optional(),
     frequency_penalty: z.nullable(z.number()).optional(),
     presence_penalty: z.nullable(z.number()).optional(),
     repetition_penalty: z.nullable(z.number()).optional(),
+    temperature: z.nullable(z.number()).optional(),
+    top_k: z.nullable(z.int()).optional(),
+    top_p: z.nullable(z.number()).optional(),
 }).transform((v) => {
     return remap$(v, {
-        "top_p": "topP",
-        "top_k": "topK",
         "frequency_penalty": "frequencyPenalty",
         "presence_penalty": "presencePenalty",
         "repetition_penalty": "repetitionPenalty",
+        "top_k": "topK",
+        "top_p": "topP",
     });
 });
 export function defaultParametersFromJSON(jsonString) {

package/esm/models/deleteguardrailresponse.d.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type DeleteGuardrailResponse = {
+    /**
+     * Confirmation that the guardrail was deleted
+     */
+    deleted: true;
+};
+/** @internal */
+export declare const DeleteGuardrailResponse$inboundSchema: z.ZodType<DeleteGuardrailResponse, unknown>;
+export declare function deleteGuardrailResponseFromJSON(jsonString: string): SafeParseResult<DeleteGuardrailResponse, SDKValidationError>;
+//# sourceMappingURL=deleteguardrailresponse.d.ts.map