@openrouter/sdk 0.5.1 → 0.9.11

package/esm/models/providersortconfig.d.ts

@@ -1,16 +1,44 @@
 import * as z from "zod/v4";
 import { OpenEnum } from "../types/enums.js";
-import { ProviderSort } from "./providersort.js";
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export declare const By: {
+    readonly Price: "price";
+    readonly Throughput: "throughput";
+    readonly Latency: "latency";
+};
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export type By = OpenEnum<typeof By>;
+/**
+ * Partitioning strategy for sorting: "model" (default) groups endpoints by model before sorting (fallback models remain fallbacks), "none" sorts all endpoints together regardless of model.
+ */
 export declare const Partition: {
     readonly Model: "model";
     readonly None: "none";
 };
+/**
+ * Partitioning strategy for sorting: "model" (default) groups endpoints by model before sorting (fallback models remain fallbacks), "none" sorts all endpoints together regardless of model.
+ */
 export type Partition = OpenEnum<typeof Partition>;
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
 export type ProviderSortConfig = {
-    by?: ProviderSort | null | undefined;
+    /**
+     * The provider sorting strategy (price, throughput, latency)
+     */
+    by?: By | null | undefined;
+    /**
+     * Partitioning strategy for sorting: "model" (default) groups endpoints by model before sorting (fallback models remain fallbacks), "none" sorts all endpoints together regardless of model.
+     */
     partition?: Partition | null | undefined;
 };
 /** @internal */
+export declare const By$outboundSchema: z.ZodType<string, By>;
+/** @internal */
 export declare const Partition$outboundSchema: z.ZodType<string, Partition>;
 /** @internal */
 export type ProviderSortConfig$Outbound = {

package/esm/models/providersortconfig.js

@@ -4,17 +4,30 @@
  */
 import * as z from "zod/v4";
 import * as openEnums from "../types/enums.js";
-import { ProviderSort$outboundSchema } from "./providersort.js";
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export const By = {
+    Price: "price",
+    Throughput: "throughput",
+    Latency: "latency",
+};
+/**
+ * Partitioning strategy for sorting: "model" (default) groups endpoints by model before sorting (fallback models remain fallbacks), "none" sorts all endpoints together regardless of model.
+ */
 export const Partition = {
     Model: "model",
     None: "none",
 };
 /** @internal */
+export const By$outboundSchema = openEnums
+    .outboundSchema(By);
+/** @internal */
 export const Partition$outboundSchema = openEnums
     .outboundSchema(Partition);
 /** @internal */
 export const ProviderSortConfig$outboundSchema = z.object({
-    by: z.nullable(ProviderSort$outboundSchema).optional(),
+    by: z.nullable(By$outboundSchema).optional(),
     partition: z.nullable(Partition$outboundSchema).optional(),
 });
 export function providerSortConfigToJSON(providerSortConfig) {

package/esm/models/publicendpoint.d.ts

@@ -7,57 +7,18 @@ import { Parameter } from "./parameter.js";
 import { PercentileStats } from "./percentilestats.js";
 import { ProviderName } from "./providername.js";
 export type Pricing = {
-    /**
-     * A value in string format that is a large number
-     */
     prompt: string;
-    /**
-     * A value in string format that is a large number
-     */
     completion: string;
-    /**
-     * A value in string format that is a large number
-     */
     request?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     image?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     imageToken?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     imageOutput?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     audio?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     audioOutput?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     inputAudioCache?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     webSearch?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     internalReasoning?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     inputCacheRead?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     inputCacheWrite?: string | undefined;
     discount?: number | undefined;
 };

package/esm/models/publicpricing.d.ts

@@ -5,57 +5,18 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  * Pricing information for the model
  */
 export type PublicPricing = {
-    /**
-     * A value in string format that is a large number
-     */
     prompt: string;
-    /**
-     * A value in string format that is a large number
-     */
     completion: string;
-    /**
-     * A value in string format that is a large number
-     */
     request?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     image?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     imageToken?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     imageOutput?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     audio?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     audioOutput?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     inputAudioCache?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     webSearch?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     internalReasoning?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     inputCacheRead?: string | undefined;
-    /**
-     * A value in string format that is a large number
-     */
     inputCacheWrite?: string | undefined;
     discount?: number | undefined;
 };

package/esm/models/reasoningdetailencrypted.d.ts

@@ -0,0 +1,42 @@
+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>;
+/**
+ * Reasoning detail encrypted schema
+ */
+export type ReasoningDetailEncrypted = {
+    type: "reasoning.encrypted";
+    data: string;
+    id?: string | null | undefined;
+    format?: ReasoningDetailEncryptedFormat | null | undefined;
+    index?: number | undefined;
+};
+/** @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;
+    index?: number | undefined;
+};
+/** @internal */
+export declare const ReasoningDetailEncrypted$outboundSchema: z.ZodType<ReasoningDetailEncrypted$Outbound, ReasoningDetailEncrypted>;
+export declare function reasoningDetailEncryptedToJSON(reasoningDetailEncrypted: ReasoningDetailEncrypted): string;
+export declare function reasoningDetailEncryptedFromJSON(jsonString: string): SafeParseResult<ReasoningDetailEncrypted, SDKValidationError>;
+//# sourceMappingURL=reasoningdetailencrypted.d.ts.map

package/esm/models/reasoningdetailencrypted.js

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 2064e7820eab
+ */
+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);
+/** @internal */
+export const ReasoningDetailEncrypted$inboundSchema = z.object({
+    type: z.literal("reasoning.encrypted"),
+    data: z.string(),
+    id: z.nullable(z.string()).optional(),
+    format: z.nullable(ReasoningDetailEncryptedFormat$inboundSchema).optional(),
+    index: z.number().optional(),
+});
+/** @internal */
+export const ReasoningDetailEncrypted$outboundSchema = z.object({
+    type: z.literal("reasoning.encrypted"),
+    data: z.string(),
+    id: z.nullable(z.string()).optional(),
+    format: z.nullable(ReasoningDetailEncryptedFormat$outboundSchema).optional(),
+    index: z.number().optional(),
+});
+export function reasoningDetailEncryptedToJSON(reasoningDetailEncrypted) {
+    return JSON.stringify(ReasoningDetailEncrypted$outboundSchema.parse(reasoningDetailEncrypted));
+}
+export function reasoningDetailEncryptedFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ReasoningDetailEncrypted$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ReasoningDetailEncrypted' from JSON`);
+}
+//# sourceMappingURL=reasoningdetailencrypted.js.map

package/esm/models/reasoningdetailsummary.d.ts

@@ -0,0 +1,42 @@
+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>;
+/**
+ * Reasoning detail summary schema
+ */
+export type ReasoningDetailSummary = {
+    type: "reasoning.summary";
+    summary: string;
+    id?: string | null | undefined;
+    format?: ReasoningDetailSummaryFormat | null | undefined;
+    index?: number | undefined;
+};
+/** @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;
+    index?: number | undefined;
+};
+/** @internal */
+export declare const ReasoningDetailSummary$outboundSchema: z.ZodType<ReasoningDetailSummary$Outbound, ReasoningDetailSummary>;
+export declare function reasoningDetailSummaryToJSON(reasoningDetailSummary: ReasoningDetailSummary): string;
+export declare function reasoningDetailSummaryFromJSON(jsonString: string): SafeParseResult<ReasoningDetailSummary, SDKValidationError>;
+//# sourceMappingURL=reasoningdetailsummary.d.ts.map

package/esm/models/reasoningdetailsummary.js

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 08e5d256b8c9
+ */
+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);
+/** @internal */
+export const ReasoningDetailSummary$inboundSchema = z.object({
+    type: z.literal("reasoning.summary"),
+    summary: z.string(),
+    id: z.nullable(z.string()).optional(),
+    format: z.nullable(ReasoningDetailSummaryFormat$inboundSchema).optional(),
+    index: z.number().optional(),
+});
+/** @internal */
+export const ReasoningDetailSummary$outboundSchema = z.object({
+    type: z.literal("reasoning.summary"),
+    summary: z.string(),
+    id: z.nullable(z.string()).optional(),
+    format: z.nullable(ReasoningDetailSummaryFormat$outboundSchema).optional(),
+    index: z.number().optional(),
+});
+export function reasoningDetailSummaryToJSON(reasoningDetailSummary) {
+    return JSON.stringify(ReasoningDetailSummary$outboundSchema.parse(reasoningDetailSummary));
+}
+export function reasoningDetailSummaryFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ReasoningDetailSummary$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ReasoningDetailSummary' from JSON`);
+}
+//# sourceMappingURL=reasoningdetailsummary.js.map

package/esm/models/reasoningdetailtext.d.ts

@@ -0,0 +1,44 @@
+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>;
+/**
+ * Reasoning detail text schema
+ */
+export type ReasoningDetailText = {
+    type: "reasoning.text";
+    text?: string | null | undefined;
+    signature?: string | null | undefined;
+    id?: string | null | undefined;
+    format?: ReasoningDetailTextFormat | null | undefined;
+    index?: number | undefined;
+};
+/** @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;
+    index?: number | undefined;
+};
+/** @internal */
+export declare const ReasoningDetailText$outboundSchema: z.ZodType<ReasoningDetailText$Outbound, ReasoningDetailText>;
+export declare function reasoningDetailTextToJSON(reasoningDetailText: ReasoningDetailText): string;
+export declare function reasoningDetailTextFromJSON(jsonString: string): SafeParseResult<ReasoningDetailText, SDKValidationError>;
+//# sourceMappingURL=reasoningdetailtext.d.ts.map

package/esm/models/reasoningdetailtext.js

@@ -0,0 +1,44 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 8b6bd4c64a66
+ */
+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);
+/** @internal */
+export const ReasoningDetailText$inboundSchema = z.object({
+    type: z.literal("reasoning.text"),
+    text: z.nullable(z.string()).optional(),
+    signature: z.nullable(z.string()).optional(),
+    id: z.nullable(z.string()).optional(),
+    format: z.nullable(ReasoningDetailTextFormat$inboundSchema).optional(),
+    index: z.number().optional(),
+});
+/** @internal */
+export const ReasoningDetailText$outboundSchema = z.object({
+    type: z.literal("reasoning.text"),
+    text: z.nullable(z.string()).optional(),
+    signature: z.nullable(z.string()).optional(),
+    id: z.nullable(z.string()).optional(),
+    format: z.nullable(ReasoningDetailTextFormat$outboundSchema).optional(),
+    index: z.number().optional(),
+});
+export function reasoningDetailTextToJSON(reasoningDetailText) {
+    return JSON.stringify(ReasoningDetailText$outboundSchema.parse(reasoningDetailText));
+}
+export function reasoningDetailTextFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ReasoningDetailText$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ReasoningDetailText' from JSON`);
+}
+//# sourceMappingURL=reasoningdetailtext.js.map

package/esm/models/reasoningdetailunion.d.ts

@@ -0,0 +1,19 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ReasoningDetailEncrypted, ReasoningDetailEncrypted$Outbound } from "./reasoningdetailencrypted.js";
+import { ReasoningDetailSummary, ReasoningDetailSummary$Outbound } from "./reasoningdetailsummary.js";
+import { ReasoningDetailText, ReasoningDetailText$Outbound } from "./reasoningdetailtext.js";
+/**
+ * Reasoning detail union schema
+ */
+export type ReasoningDetailUnion = ReasoningDetailSummary | ReasoningDetailEncrypted | ReasoningDetailText;
+/** @internal */
+export declare const ReasoningDetailUnion$inboundSchema: z.ZodType<ReasoningDetailUnion, unknown>;
+/** @internal */
+export type ReasoningDetailUnion$Outbound = ReasoningDetailSummary$Outbound | ReasoningDetailEncrypted$Outbound | ReasoningDetailText$Outbound;
+/** @internal */
+export declare const ReasoningDetailUnion$outboundSchema: z.ZodType<ReasoningDetailUnion$Outbound, ReasoningDetailUnion>;
+export declare function reasoningDetailUnionToJSON(reasoningDetailUnion: ReasoningDetailUnion): string;
+export declare function reasoningDetailUnionFromJSON(jsonString: string): SafeParseResult<ReasoningDetailUnion, SDKValidationError>;
+//# sourceMappingURL=reasoningdetailunion.d.ts.map

package/esm/models/reasoningdetailunion.js

@@ -0,0 +1,28 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: a224fd99cdb5
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.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,
+]);
+/** @internal */
+export const ReasoningDetailUnion$outboundSchema = z.union([
+    ReasoningDetailSummary$outboundSchema,
+    ReasoningDetailEncrypted$outboundSchema,
+    ReasoningDetailText$outboundSchema,
+]);
+export function reasoningDetailUnionToJSON(reasoningDetailUnion) {
+    return JSON.stringify(ReasoningDetailUnion$outboundSchema.parse(reasoningDetailUnion));
+}
+export function reasoningDetailUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ReasoningDetailUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ReasoningDetailUnion' from JSON`);
+}
+//# sourceMappingURL=reasoningdetailunion.js.map

package/esm/models/responseformatjsonobject.d.ts

@@ -0,0 +1,20 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * JSON object response format
+ */
+export type ResponseFormatJSONObject = {
+    type: "json_object";
+};
+/** @internal */
+export declare const ResponseFormatJSONObject$inboundSchema: z.ZodType<ResponseFormatJSONObject, unknown>;
+/** @internal */
+export type ResponseFormatJSONObject$Outbound = {
+    type: "json_object";
+};
+/** @internal */
+export declare const ResponseFormatJSONObject$outboundSchema: z.ZodType<ResponseFormatJSONObject$Outbound, ResponseFormatJSONObject>;
+export declare function responseFormatJSONObjectToJSON(responseFormatJSONObject: ResponseFormatJSONObject): string;
+export declare function responseFormatJSONObjectFromJSON(jsonString: string): SafeParseResult<ResponseFormatJSONObject, SDKValidationError>;
+//# sourceMappingURL=responseformatjsonobject.d.ts.map

package/esm/models/responseformatjsonobject.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: bb0b83e33de9
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const ResponseFormatJSONObject$inboundSchema = z.object({
+    type: z.literal("json_object"),
+});
+/** @internal */
+export const ResponseFormatJSONObject$outboundSchema = z.object({
+    type: z.literal("json_object"),
+});
+export function responseFormatJSONObjectToJSON(responseFormatJSONObject) {
+    return JSON.stringify(ResponseFormatJSONObject$outboundSchema.parse(responseFormatJSONObject));
+}
+export function responseFormatJSONObjectFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ResponseFormatJSONObject$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponseFormatJSONObject' from JSON`);
+}
+//# sourceMappingURL=responseformatjsonobject.js.map

package/esm/models/responseformatjsonschema.d.ts

@@ -1,7 +1,13 @@
 import * as z from "zod/v4";
 import { JSONSchemaConfig, JSONSchemaConfig$Outbound } from "./jsonschemaconfig.js";
+/**
+ * JSON Schema response format for structured outputs
+ */
 export type ResponseFormatJSONSchema = {
     type: "json_schema";
+    /**
+     * JSON Schema configuration object
+     */
     jsonSchema: JSONSchemaConfig;
 };
 /** @internal */

package/esm/models/responseformattext.d.ts

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

package/esm/models/responseformattext.js

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

package/esm/models/responseformattextconfig.d.ts

@@ -1,17 +1,17 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { ResponsesFormatJSONObject, ResponsesFormatJSONObject$Outbound } from "./responsesformatjsonobject.js";
+import { ResponseFormatJSONObject, ResponseFormatJSONObject$Outbound } from "./responseformatjsonobject.js";
 import { ResponsesFormatText, ResponsesFormatText$Outbound } from "./responsesformattext.js";
 import { ResponsesFormatTextJSONSchemaConfig, ResponsesFormatTextJSONSchemaConfig$Outbound } from "./responsesformattextjsonschemaconfig.js";
 /**
  * Text response format configuration
  */
-export type ResponseFormatTextConfig = ResponsesFormatText | ResponsesFormatJSONObject | ResponsesFormatTextJSONSchemaConfig;
+export type ResponseFormatTextConfig = ResponsesFormatText | ResponseFormatJSONObject | ResponsesFormatTextJSONSchemaConfig;
 /** @internal */
 export declare const ResponseFormatTextConfig$inboundSchema: z.ZodType<ResponseFormatTextConfig, unknown>;
 /** @internal */
-export type ResponseFormatTextConfig$Outbound = ResponsesFormatText$Outbound | ResponsesFormatJSONObject$Outbound | ResponsesFormatTextJSONSchemaConfig$Outbound;
+export type ResponseFormatTextConfig$Outbound = ResponsesFormatText$Outbound | ResponseFormatJSONObject$Outbound | ResponsesFormatTextJSONSchemaConfig$Outbound;
 /** @internal */
 export declare const ResponseFormatTextConfig$outboundSchema: z.ZodType<ResponseFormatTextConfig$Outbound, ResponseFormatTextConfig>;
 export declare function responseFormatTextConfigToJSON(responseFormatTextConfig: ResponseFormatTextConfig): string;

package/esm/models/responseformattextconfig.js

@@ -4,19 +4,19 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import { ResponsesFormatJSONObject$inboundSchema, ResponsesFormatJSONObject$outboundSchema, } from "./responsesformatjsonobject.js";
+import { ResponseFormatJSONObject$inboundSchema, ResponseFormatJSONObject$outboundSchema, } from "./responseformatjsonobject.js";
 import { ResponsesFormatText$inboundSchema, ResponsesFormatText$outboundSchema, } from "./responsesformattext.js";
 import { ResponsesFormatTextJSONSchemaConfig$inboundSchema, ResponsesFormatTextJSONSchemaConfig$outboundSchema, } from "./responsesformattextjsonschemaconfig.js";
 /** @internal */
 export const ResponseFormatTextConfig$inboundSchema = z.union([
     ResponsesFormatText$inboundSchema,
-    ResponsesFormatJSONObject$inboundSchema,
+    ResponseFormatJSONObject$inboundSchema,
     ResponsesFormatTextJSONSchemaConfig$inboundSchema,
 ]);
 /** @internal */
 export const ResponseFormatTextConfig$outboundSchema = z.union([
     ResponsesFormatText$outboundSchema,
-    ResponsesFormatJSONObject$outboundSchema,
+    ResponseFormatJSONObject$outboundSchema,
     ResponsesFormatTextJSONSchemaConfig$outboundSchema,
 ]);
 export function responseFormatTextConfigToJSON(responseFormatTextConfig) {

package/esm/models/responseformattextgrammar.d.ts

@@ -1,6 +1,12 @@
 import * as z from "zod/v4";
+/**
+ * Custom grammar response format
+ */
 export type ResponseFormatTextGrammar = {
     type: "grammar";
+    /**
+     * Custom grammar for text generation
+     */
     grammar: string;
 };
 /** @internal */