@openrouter/sdk 0.11.2 → 0.12.0

package/esm/models/publicpricing.d.ts

@@ -5,20 +5,20 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  * Pricing information for the model
  */
 export type PublicPricing = {
-    prompt: string;
+    audio?: string | undefined;
+    audioOutput?: string | undefined;
     completion: string;
-    request?: string | undefined;
+    discount?: number | undefined;
     image?: string | undefined;
-    imageToken?: string | undefined;
     imageOutput?: string | undefined;
-    audio?: string | undefined;
-    audioOutput?: string | undefined;
+    imageToken?: string | undefined;
     inputAudioCache?: string | undefined;
-    webSearch?: string | undefined;
-    internalReasoning?: string | undefined;
     inputCacheRead?: string | undefined;
     inputCacheWrite?: string | undefined;
-    discount?: number | undefined;
+    internalReasoning?: string | undefined;
+    prompt: string;
+    request?: string | undefined;
+    webSearch?: string | undefined;
 };
 /** @internal */
 export declare const PublicPricing$inboundSchema: z.ZodType<PublicPricing, unknown>;

package/esm/models/publicpricing.js

@@ -8,30 +8,30 @@ import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const PublicPricing$inboundSchema = z
     .object({
-    prompt: z.string(),
+    audio: z.string().optional(),
+    audio_output: z.string().optional(),
     completion: z.string(),
-    request: z.string().optional(),
+    discount: z.number().optional(),
     image: z.string().optional(),
-    image_token: z.string().optional(),
     image_output: z.string().optional(),
-    audio: z.string().optional(),
-    audio_output: z.string().optional(),
+    image_token: z.string().optional(),
     input_audio_cache: z.string().optional(),
-    web_search: z.string().optional(),
-    internal_reasoning: z.string().optional(),
     input_cache_read: z.string().optional(),
     input_cache_write: z.string().optional(),
-    discount: z.number().optional(),
+    internal_reasoning: z.string().optional(),
+    prompt: z.string(),
+    request: z.string().optional(),
+    web_search: z.string().optional(),
 }).transform((v) => {
     return remap$(v, {
-        "image_token": "imageToken",
-        "image_output": "imageOutput",
         "audio_output": "audioOutput",
+        "image_output": "imageOutput",
+        "image_token": "imageToken",
         "input_audio_cache": "inputAudioCache",
-        "web_search": "webSearch",
-        "internal_reasoning": "internalReasoning",
         "input_cache_read": "inputCacheRead",
         "input_cache_write": "inputCacheWrite",
+        "internal_reasoning": "internalReasoning",
+        "web_search": "webSearch",
     });
 });
 export function publicPricingFromJSON(jsonString) {

package/esm/models/reasoningconfig.d.ts

@@ -1,21 +1,21 @@
 import * as z from "zod/v4";
-import { ReasoningEffortEnum } from "./reasoningeffortenum.js";
-import { ReasoningSummaryVerbosityEnum } from "./reasoningsummaryverbosityenum.js";
+import { ReasoningEffort } from "./reasoningeffort.js";
+import { ReasoningSummaryVerbosity } from "./reasoningsummaryverbosity.js";
 /**
  * Configuration for reasoning mode in the response
  */
 export type ReasoningConfig = {
-    effort?: ReasoningEffortEnum | null | undefined;
-    summary?: ReasoningSummaryVerbosityEnum | null | undefined;
-    maxTokens?: number | null | undefined;
+    effort?: ReasoningEffort | null | undefined;
+    summary?: ReasoningSummaryVerbosity | null | undefined;
     enabled?: boolean | null | undefined;
+    maxTokens?: number | undefined;
 };
 /** @internal */
 export type ReasoningConfig$Outbound = {
     effort?: string | null | undefined;
     summary?: string | null | undefined;
-    max_tokens?: number | null | undefined;
     enabled?: boolean | null | undefined;
+    max_tokens?: number | undefined;
 };
 /** @internal */
 export declare const ReasoningConfig$outboundSchema: z.ZodType<ReasoningConfig$Outbound, ReasoningConfig>;

package/esm/models/reasoningconfig.js

@@ -4,14 +4,14 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
-import { ReasoningEffortEnum$outboundSchema, } from "./reasoningeffortenum.js";
-import { ReasoningSummaryVerbosityEnum$outboundSchema, } from "./reasoningsummaryverbosityenum.js";
+import { ReasoningEffort$outboundSchema, } from "./reasoningeffort.js";
+import { ReasoningSummaryVerbosity$outboundSchema, } from "./reasoningsummaryverbosity.js";
 /** @internal */
 export const ReasoningConfig$outboundSchema = z.object({
-    effort: z.nullable(ReasoningEffortEnum$outboundSchema).optional(),
-    summary: z.nullable(ReasoningSummaryVerbosityEnum$outboundSchema).optional(),
-    maxTokens: z.nullable(z.number()).optional(),
+    effort: z.nullable(ReasoningEffort$outboundSchema).optional(),
+    summary: z.nullable(ReasoningSummaryVerbosity$outboundSchema).optional(),
     enabled: z.nullable(z.boolean()).optional(),
+    maxTokens: z.int().optional(),
 }).transform((v) => {
     return remap$(v, {
         maxTokens: "max_tokens",

package/esm/models/reasoningdeltaevent.d.ts

@@ -5,12 +5,12 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  * Event emitted when reasoning text delta is streamed
  */
 export type ReasoningDeltaEvent = {
-    type: "response.reasoning_text.delta";
-    outputIndex: number;
-    itemId: string;
     contentIndex: number;
     delta: string;
+    itemId: string;
+    outputIndex: number;
     sequenceNumber: number;
+    type: "response.reasoning_text.delta";
 };
 /** @internal */
 export declare const ReasoningDeltaEvent$inboundSchema: z.ZodType<ReasoningDeltaEvent, unknown>;

package/esm/models/reasoningdeltaevent.js

@@ -7,17 +7,17 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const ReasoningDeltaEvent$inboundSchema = z.object({
-    type: z.literal("response.reasoning_text.delta"),
-    output_index: z.number(),
-    item_id: z.string(),
-    content_index: z.number(),
+    content_index: z.int(),
     delta: z.string(),
-    sequence_number: z.number(),
+    item_id: z.string(),
+    output_index: z.int(),
+    sequence_number: z.int(),
+    type: z.literal("response.reasoning_text.delta"),
 }).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/reasoningdetailencrypted.d.ts

@@ -1,39 +1,26 @@
 import * as z from "zod/v4";
-import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const ReasoningDetailEncryptedFormat: {
-    readonly Unknown: "unknown";
-    readonly OpenaiResponsesV1: "openai-responses-v1";
-    readonly AzureOpenaiResponsesV1: "azure-openai-responses-v1";
-    readonly XaiResponsesV1: "xai-responses-v1";
-    readonly AnthropicClaudeV1: "anthropic-claude-v1";
-    readonly GoogleGeminiV1: "google-gemini-v1";
-};
-export type ReasoningDetailEncryptedFormat = OpenEnum<typeof ReasoningDetailEncryptedFormat>;
+import { ReasoningFormat } from "./reasoningformat.js";
 /**
  * Reasoning detail encrypted schema
  */
 export type ReasoningDetailEncrypted = {
-    type: "reasoning.encrypted";
     data: string;
+    format?: ReasoningFormat | null | undefined;
     id?: string | null | undefined;
-    format?: ReasoningDetailEncryptedFormat | null | undefined;
     index?: number | undefined;
+    type: "reasoning.encrypted";
 };
 /** @internal */
-export declare const ReasoningDetailEncryptedFormat$inboundSchema: z.ZodType<ReasoningDetailEncryptedFormat, unknown>;
-/** @internal */
-export declare const ReasoningDetailEncryptedFormat$outboundSchema: z.ZodType<string, ReasoningDetailEncryptedFormat>;
-/** @internal */
 export declare const ReasoningDetailEncrypted$inboundSchema: z.ZodType<ReasoningDetailEncrypted, unknown>;
 /** @internal */
 export type ReasoningDetailEncrypted$Outbound = {
-    type: "reasoning.encrypted";
     data: string;
-    id?: string | null | undefined;
     format?: string | null | undefined;
+    id?: string | null | undefined;
     index?: number | undefined;
+    type: "reasoning.encrypted";
 };
 /** @internal */
 export declare const ReasoningDetailEncrypted$outboundSchema: z.ZodType<ReasoningDetailEncrypted$Outbound, ReasoningDetailEncrypted>;

package/esm/models/reasoningdetailencrypted.js

@@ -4,34 +4,22 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import * as openEnums from "../types/enums.js";
-export const ReasoningDetailEncryptedFormat = {
-    Unknown: "unknown",
-    OpenaiResponsesV1: "openai-responses-v1",
-    AzureOpenaiResponsesV1: "azure-openai-responses-v1",
-    XaiResponsesV1: "xai-responses-v1",
-    AnthropicClaudeV1: "anthropic-claude-v1",
-    GoogleGeminiV1: "google-gemini-v1",
-};
-/** @internal */
-export const ReasoningDetailEncryptedFormat$inboundSchema = openEnums.inboundSchema(ReasoningDetailEncryptedFormat);
-/** @internal */
-export const ReasoningDetailEncryptedFormat$outboundSchema = openEnums.outboundSchema(ReasoningDetailEncryptedFormat);
+import { ReasoningFormat$inboundSchema, ReasoningFormat$outboundSchema, } from "./reasoningformat.js";
 /** @internal */
 export const ReasoningDetailEncrypted$inboundSchema = z.object({
-    type: z.literal("reasoning.encrypted"),
     data: z.string(),
+    format: z.nullable(ReasoningFormat$inboundSchema).optional(),
     id: z.nullable(z.string()).optional(),
-    format: z.nullable(ReasoningDetailEncryptedFormat$inboundSchema).optional(),
-    index: z.number().optional(),
+    index: z.int().optional(),
+    type: z.literal("reasoning.encrypted"),
 });
 /** @internal */
 export const ReasoningDetailEncrypted$outboundSchema = z.object({
-    type: z.literal("reasoning.encrypted"),
     data: z.string(),
+    format: z.nullable(ReasoningFormat$outboundSchema).optional(),
     id: z.nullable(z.string()).optional(),
-    format: z.nullable(ReasoningDetailEncryptedFormat$outboundSchema).optional(),
-    index: z.number().optional(),
+    index: z.int().optional(),
+    type: z.literal("reasoning.encrypted"),
 });
 export function reasoningDetailEncryptedToJSON(reasoningDetailEncrypted) {
     return JSON.stringify(ReasoningDetailEncrypted$outboundSchema.parse(reasoningDetailEncrypted));

package/esm/models/reasoningdetailsummary.d.ts

@@ -1,39 +1,26 @@
 import * as z from "zod/v4";
-import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const ReasoningDetailSummaryFormat: {
-    readonly Unknown: "unknown";
-    readonly OpenaiResponsesV1: "openai-responses-v1";
-    readonly AzureOpenaiResponsesV1: "azure-openai-responses-v1";
-    readonly XaiResponsesV1: "xai-responses-v1";
-    readonly AnthropicClaudeV1: "anthropic-claude-v1";
-    readonly GoogleGeminiV1: "google-gemini-v1";
-};
-export type ReasoningDetailSummaryFormat = OpenEnum<typeof ReasoningDetailSummaryFormat>;
+import { ReasoningFormat } from "./reasoningformat.js";
 /**
  * Reasoning detail summary schema
  */
 export type ReasoningDetailSummary = {
-    type: "reasoning.summary";
-    summary: string;
+    format?: ReasoningFormat | null | undefined;
     id?: string | null | undefined;
-    format?: ReasoningDetailSummaryFormat | null | undefined;
     index?: number | undefined;
+    summary: string;
+    type: "reasoning.summary";
 };
 /** @internal */
-export declare const ReasoningDetailSummaryFormat$inboundSchema: z.ZodType<ReasoningDetailSummaryFormat, unknown>;
-/** @internal */
-export declare const ReasoningDetailSummaryFormat$outboundSchema: z.ZodType<string, ReasoningDetailSummaryFormat>;
-/** @internal */
 export declare const ReasoningDetailSummary$inboundSchema: z.ZodType<ReasoningDetailSummary, unknown>;
 /** @internal */
 export type ReasoningDetailSummary$Outbound = {
-    type: "reasoning.summary";
-    summary: string;
-    id?: string | null | undefined;
     format?: string | null | undefined;
+    id?: string | null | undefined;
     index?: number | undefined;
+    summary: string;
+    type: "reasoning.summary";
 };
 /** @internal */
 export declare const ReasoningDetailSummary$outboundSchema: z.ZodType<ReasoningDetailSummary$Outbound, ReasoningDetailSummary>;

package/esm/models/reasoningdetailsummary.js

@@ -4,34 +4,22 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import * as openEnums from "../types/enums.js";
-export const ReasoningDetailSummaryFormat = {
-    Unknown: "unknown",
-    OpenaiResponsesV1: "openai-responses-v1",
-    AzureOpenaiResponsesV1: "azure-openai-responses-v1",
-    XaiResponsesV1: "xai-responses-v1",
-    AnthropicClaudeV1: "anthropic-claude-v1",
-    GoogleGeminiV1: "google-gemini-v1",
-};
-/** @internal */
-export const ReasoningDetailSummaryFormat$inboundSchema = openEnums.inboundSchema(ReasoningDetailSummaryFormat);
-/** @internal */
-export const ReasoningDetailSummaryFormat$outboundSchema = openEnums.outboundSchema(ReasoningDetailSummaryFormat);
+import { ReasoningFormat$inboundSchema, ReasoningFormat$outboundSchema, } from "./reasoningformat.js";
 /** @internal */
 export const ReasoningDetailSummary$inboundSchema = z.object({
-    type: z.literal("reasoning.summary"),
-    summary: z.string(),
+    format: z.nullable(ReasoningFormat$inboundSchema).optional(),
     id: z.nullable(z.string()).optional(),
-    format: z.nullable(ReasoningDetailSummaryFormat$inboundSchema).optional(),
-    index: z.number().optional(),
+    index: z.int().optional(),
+    summary: z.string(),
+    type: z.literal("reasoning.summary"),
 });
 /** @internal */
 export const ReasoningDetailSummary$outboundSchema = z.object({
-    type: z.literal("reasoning.summary"),
-    summary: z.string(),
+    format: z.nullable(ReasoningFormat$outboundSchema).optional(),
     id: z.nullable(z.string()).optional(),
-    format: z.nullable(ReasoningDetailSummaryFormat$outboundSchema).optional(),
-    index: z.number().optional(),
+    index: z.int().optional(),
+    summary: z.string(),
+    type: z.literal("reasoning.summary"),
 });
 export function reasoningDetailSummaryToJSON(reasoningDetailSummary) {
     return JSON.stringify(ReasoningDetailSummary$outboundSchema.parse(reasoningDetailSummary));

package/esm/models/reasoningdetailtext.d.ts

@@ -1,41 +1,28 @@
 import * as z from "zod/v4";
-import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const ReasoningDetailTextFormat: {
-    readonly Unknown: "unknown";
-    readonly OpenaiResponsesV1: "openai-responses-v1";
-    readonly AzureOpenaiResponsesV1: "azure-openai-responses-v1";
-    readonly XaiResponsesV1: "xai-responses-v1";
-    readonly AnthropicClaudeV1: "anthropic-claude-v1";
-    readonly GoogleGeminiV1: "google-gemini-v1";
-};
-export type ReasoningDetailTextFormat = OpenEnum<typeof ReasoningDetailTextFormat>;
+import { ReasoningFormat } from "./reasoningformat.js";
 /**
  * Reasoning detail text schema
  */
 export type ReasoningDetailText = {
-    type: "reasoning.text";
-    text?: string | null | undefined;
-    signature?: string | null | undefined;
+    format?: ReasoningFormat | null | undefined;
     id?: string | null | undefined;
-    format?: ReasoningDetailTextFormat | null | undefined;
     index?: number | undefined;
+    signature?: string | null | undefined;
+    text?: string | null | undefined;
+    type: "reasoning.text";
 };
 /** @internal */
-export declare const ReasoningDetailTextFormat$inboundSchema: z.ZodType<ReasoningDetailTextFormat, unknown>;
-/** @internal */
-export declare const ReasoningDetailTextFormat$outboundSchema: z.ZodType<string, ReasoningDetailTextFormat>;
-/** @internal */
 export declare const ReasoningDetailText$inboundSchema: z.ZodType<ReasoningDetailText, unknown>;
 /** @internal */
 export type ReasoningDetailText$Outbound = {
-    type: "reasoning.text";
-    text?: string | null | undefined;
-    signature?: string | null | undefined;
-    id?: string | null | undefined;
     format?: string | null | undefined;
+    id?: string | null | undefined;
     index?: number | undefined;
+    signature?: string | null | undefined;
+    text?: string | null | undefined;
+    type: "reasoning.text";
 };
 /** @internal */
 export declare const ReasoningDetailText$outboundSchema: z.ZodType<ReasoningDetailText$Outbound, ReasoningDetailText>;

package/esm/models/reasoningdetailtext.js

@@ -4,36 +4,24 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import * as openEnums from "../types/enums.js";
-export const ReasoningDetailTextFormat = {
-    Unknown: "unknown",
-    OpenaiResponsesV1: "openai-responses-v1",
-    AzureOpenaiResponsesV1: "azure-openai-responses-v1",
-    XaiResponsesV1: "xai-responses-v1",
-    AnthropicClaudeV1: "anthropic-claude-v1",
-    GoogleGeminiV1: "google-gemini-v1",
-};
-/** @internal */
-export const ReasoningDetailTextFormat$inboundSchema = openEnums.inboundSchema(ReasoningDetailTextFormat);
-/** @internal */
-export const ReasoningDetailTextFormat$outboundSchema = openEnums.outboundSchema(ReasoningDetailTextFormat);
+import { ReasoningFormat$inboundSchema, ReasoningFormat$outboundSchema, } from "./reasoningformat.js";
 /** @internal */
 export const ReasoningDetailText$inboundSchema = z.object({
-    type: z.literal("reasoning.text"),
-    text: z.nullable(z.string()).optional(),
-    signature: z.nullable(z.string()).optional(),
+    format: z.nullable(ReasoningFormat$inboundSchema).optional(),
     id: z.nullable(z.string()).optional(),
-    format: z.nullable(ReasoningDetailTextFormat$inboundSchema).optional(),
-    index: z.number().optional(),
+    index: z.int().optional(),
+    signature: z.nullable(z.string()).optional(),
+    text: z.nullable(z.string()).optional(),
+    type: z.literal("reasoning.text"),
 });
 /** @internal */
 export const ReasoningDetailText$outboundSchema = z.object({
-    type: z.literal("reasoning.text"),
-    text: z.nullable(z.string()).optional(),
-    signature: z.nullable(z.string()).optional(),
+    format: z.nullable(ReasoningFormat$outboundSchema).optional(),
     id: z.nullable(z.string()).optional(),
-    format: z.nullable(ReasoningDetailTextFormat$outboundSchema).optional(),
-    index: z.number().optional(),
+    index: z.int().optional(),
+    signature: z.nullable(z.string()).optional(),
+    text: z.nullable(z.string()).optional(),
+    type: z.literal("reasoning.text"),
 });
 export function reasoningDetailTextToJSON(reasoningDetailText) {
     return JSON.stringify(ReasoningDetailText$outboundSchema.parse(reasoningDetailText));

package/esm/models/reasoningdetailunion.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 { ReasoningDetailEncrypted, ReasoningDetailEncrypted$Outbound } from "./reasoningdetailencrypted.js";
@@ -7,11 +8,11 @@ import { ReasoningDetailText, ReasoningDetailText$Outbound } from "./reasoningde
 /**
  * Reasoning detail union schema
  */
-export type ReasoningDetailUnion = ReasoningDetailSummary | ReasoningDetailEncrypted | ReasoningDetailText;
+export type ReasoningDetailUnion = ReasoningDetailEncrypted | ReasoningDetailSummary | ReasoningDetailText | discriminatedUnionTypes.Unknown<"type">;
 /** @internal */
 export declare const ReasoningDetailUnion$inboundSchema: z.ZodType<ReasoningDetailUnion, unknown>;
 /** @internal */
-export type ReasoningDetailUnion$Outbound = ReasoningDetailSummary$Outbound | ReasoningDetailEncrypted$Outbound | ReasoningDetailText$Outbound;
+export type ReasoningDetailUnion$Outbound = ReasoningDetailEncrypted$Outbound | ReasoningDetailSummary$Outbound | ReasoningDetailText$Outbound;
 /** @internal */
 export declare const ReasoningDetailUnion$outboundSchema: z.ZodType<ReasoningDetailUnion$Outbound, ReasoningDetailUnion>;
 export declare function reasoningDetailUnionToJSON(reasoningDetailUnion: ReasoningDetailUnion): string;

package/esm/models/reasoningdetailunion.js

@@ -4,19 +4,20 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
 import { ReasoningDetailEncrypted$inboundSchema, ReasoningDetailEncrypted$outboundSchema, } from "./reasoningdetailencrypted.js";
 import { ReasoningDetailSummary$inboundSchema, ReasoningDetailSummary$outboundSchema, } from "./reasoningdetailsummary.js";
 import { ReasoningDetailText$inboundSchema, ReasoningDetailText$outboundSchema, } from "./reasoningdetailtext.js";
 /** @internal */
-export const ReasoningDetailUnion$inboundSchema = z.union([
-    ReasoningDetailSummary$inboundSchema,
-    ReasoningDetailEncrypted$inboundSchema,
-    ReasoningDetailText$inboundSchema,
-]);
+export const ReasoningDetailUnion$inboundSchema = discriminatedUnion("type", {
+    ["reasoning.encrypted"]: ReasoningDetailEncrypted$inboundSchema,
+    ["reasoning.summary"]: ReasoningDetailSummary$inboundSchema,
+    ["reasoning.text"]: ReasoningDetailText$inboundSchema,
+});
 /** @internal */
 export const ReasoningDetailUnion$outboundSchema = z.union([
-    ReasoningDetailSummary$outboundSchema,
     ReasoningDetailEncrypted$outboundSchema,
+    ReasoningDetailSummary$outboundSchema,
     ReasoningDetailText$outboundSchema,
 ]);
 export function reasoningDetailUnionToJSON(reasoningDetailUnion) {

package/esm/models/reasoningdoneevent.d.ts

@@ -5,12 +5,12 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  * Event emitted when reasoning text streaming is complete
  */
 export type ReasoningDoneEvent = {
-    type: "response.reasoning_text.done";
-    outputIndex: number;
-    itemId: string;
     contentIndex: number;
-    text: string;
+    itemId: string;
+    outputIndex: number;
     sequenceNumber: number;
+    text: string;
+    type: "response.reasoning_text.done";
 };
 /** @internal */
 export declare const ReasoningDoneEvent$inboundSchema: z.ZodType<ReasoningDoneEvent, unknown>;

package/esm/models/reasoningdoneevent.js

@@ -7,17 +7,17 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const ReasoningDoneEvent$inboundSchema = z.object({
-    type: z.literal("response.reasoning_text.done"),
-    output_index: z.number(),
+    content_index: z.int(),
     item_id: z.string(),
-    content_index: z.number(),
+    output_index: z.int(),
+    sequence_number: z.int(),
     text: z.string(),
-    sequence_number: z.number(),
+    type: z.literal("response.reasoning_text.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/reasoningeffort.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+export declare const ReasoningEffort: {
+    readonly Xhigh: "xhigh";
+    readonly High: "high";
+    readonly Medium: "medium";
+    readonly Low: "low";
+    readonly Minimal: "minimal";
+    readonly None: "none";
+};
+export type ReasoningEffort = OpenEnum<typeof ReasoningEffort>;
+/** @internal */
+export declare const ReasoningEffort$inboundSchema: z.ZodType<ReasoningEffort, unknown>;
+/** @internal */
+export declare const ReasoningEffort$outboundSchema: z.ZodType<string, ReasoningEffort>;
+//# sourceMappingURL=reasoningeffort.d.ts.map

package/esm/models/reasoningeffort.js

@@ -0,0 +1,18 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: dd747014f9d3
+ */
+import * as openEnums from "../types/enums.js";
+export const ReasoningEffort = {
+    Xhigh: "xhigh",
+    High: "high",
+    Medium: "medium",
+    Low: "low",
+    Minimal: "minimal",
+    None: "none",
+};
+/** @internal */
+export const ReasoningEffort$inboundSchema = openEnums.inboundSchema(ReasoningEffort);
+/** @internal */
+export const ReasoningEffort$outboundSchema = openEnums.outboundSchema(ReasoningEffort);
+//# sourceMappingURL=reasoningeffort.js.map

package/esm/models/reasoningformat.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+export declare const ReasoningFormat: {
+    readonly Unknown: "unknown";
+    readonly OpenaiResponsesV1: "openai-responses-v1";
+    readonly AzureOpenaiResponsesV1: "azure-openai-responses-v1";
+    readonly XaiResponsesV1: "xai-responses-v1";
+    readonly AnthropicClaudeV1: "anthropic-claude-v1";
+    readonly GoogleGeminiV1: "google-gemini-v1";
+};
+export type ReasoningFormat = OpenEnum<typeof ReasoningFormat>;
+/** @internal */
+export declare const ReasoningFormat$inboundSchema: z.ZodType<ReasoningFormat, unknown>;
+/** @internal */
+export declare const ReasoningFormat$outboundSchema: z.ZodType<string, ReasoningFormat>;
+//# sourceMappingURL=reasoningformat.d.ts.map

package/esm/models/reasoningformat.js

@@ -0,0 +1,18 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: b523cf757168
+ */
+import * as openEnums from "../types/enums.js";
+export const ReasoningFormat = {
+    Unknown: "unknown",
+    OpenaiResponsesV1: "openai-responses-v1",
+    AzureOpenaiResponsesV1: "azure-openai-responses-v1",
+    XaiResponsesV1: "xai-responses-v1",
+    AnthropicClaudeV1: "anthropic-claude-v1",
+    GoogleGeminiV1: "google-gemini-v1",
+};
+/** @internal */
+export const ReasoningFormat$inboundSchema = openEnums.inboundSchema(ReasoningFormat);
+/** @internal */
+export const ReasoningFormat$outboundSchema = openEnums.outboundSchema(ReasoningFormat);
+//# sourceMappingURL=reasoningformat.js.map