@openrouter/sdk 0.8.0 → 0.10.2

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 */

package/esm/models/responseformattextpython.d.ts

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

package/esm/models/responseformattextpython.js

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

package/esm/models/responseoutputtext.d.ts

@@ -7,7 +7,7 @@ export type ResponseOutputTextTopLogprob = {
     bytes: Array<number>;
     logprob: number;
 };
-export type Logprob = {
+export type ResponseOutputTextLogprob = {
     token: string;
     bytes: Array<number>;
     logprob: number;
@@ -17,7 +17,7 @@ export type ResponseOutputText = {
     type: "output_text";
     text: string;
     annotations?: Array<OpenAIResponsesAnnotation> | undefined;
-    logprobs?: Array<Logprob> | undefined;
+    logprobs?: Array<ResponseOutputTextLogprob> | undefined;
 };
 /** @internal */
 export declare const ResponseOutputTextTopLogprob$inboundSchema: z.ZodType<ResponseOutputTextTopLogprob, unknown>;
@@ -32,18 +32,18 @@ export declare const ResponseOutputTextTopLogprob$outboundSchema: z.ZodType<Resp
 export declare function responseOutputTextTopLogprobToJSON(responseOutputTextTopLogprob: ResponseOutputTextTopLogprob): string;
 export declare function responseOutputTextTopLogprobFromJSON(jsonString: string): SafeParseResult<ResponseOutputTextTopLogprob, SDKValidationError>;
 /** @internal */
-export declare const Logprob$inboundSchema: z.ZodType<Logprob, unknown>;
+export declare const ResponseOutputTextLogprob$inboundSchema: z.ZodType<ResponseOutputTextLogprob, unknown>;
 /** @internal */
-export type Logprob$Outbound = {
+export type ResponseOutputTextLogprob$Outbound = {
     token: string;
     bytes: Array<number>;
     logprob: number;
     top_logprobs: Array<ResponseOutputTextTopLogprob$Outbound>;
 };
 /** @internal */
-export declare const Logprob$outboundSchema: z.ZodType<Logprob$Outbound, Logprob>;
-export declare function logprobToJSON(logprob: Logprob): string;
-export declare function logprobFromJSON(jsonString: string): SafeParseResult<Logprob, SDKValidationError>;
+export declare const ResponseOutputTextLogprob$outboundSchema: z.ZodType<ResponseOutputTextLogprob$Outbound, ResponseOutputTextLogprob>;
+export declare function responseOutputTextLogprobToJSON(responseOutputTextLogprob: ResponseOutputTextLogprob): string;
+export declare function responseOutputTextLogprobFromJSON(jsonString: string): SafeParseResult<ResponseOutputTextLogprob, SDKValidationError>;
 /** @internal */
 export declare const ResponseOutputText$inboundSchema: z.ZodType<ResponseOutputText, unknown>;
 /** @internal */
@@ -51,7 +51,7 @@ export type ResponseOutputText$Outbound = {
     type: "output_text";
     text: string;
     annotations?: Array<OpenAIResponsesAnnotation$Outbound> | undefined;
-    logprobs?: Array<Logprob$Outbound> | undefined;
+    logprobs?: Array<ResponseOutputTextLogprob$Outbound> | undefined;
 };
 /** @internal */
 export declare const ResponseOutputText$outboundSchema: z.ZodType<ResponseOutputText$Outbound, ResponseOutputText>;

package/esm/models/responseoutputtext.js

@@ -25,7 +25,7 @@ export function responseOutputTextTopLogprobFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ResponseOutputTextTopLogprob$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponseOutputTextTopLogprob' from JSON`);
 }
 /** @internal */
-export const Logprob$inboundSchema = z.object({
+export const ResponseOutputTextLogprob$inboundSchema = z.object({
     token: z.string(),
     bytes: z.array(z.number()),
     logprob: z.number(),
@@ -36,8 +36,7 @@ export const Logprob$inboundSchema = z.object({
     });
 });
 /** @internal */
-export const Logprob$outboundSchema = z
-    .object({
+export const ResponseOutputTextLogprob$outboundSchema = z.object({
     token: z.string(),
     bytes: z.array(z.number()),
     logprob: z.number(),
@@ -47,25 +46,27 @@ export const Logprob$outboundSchema = z
         topLogprobs: "top_logprobs",
     });
 });
-export function logprobToJSON(logprob) {
-    return JSON.stringify(Logprob$outboundSchema.parse(logprob));
+export function responseOutputTextLogprobToJSON(responseOutputTextLogprob) {
+    return JSON.stringify(ResponseOutputTextLogprob$outboundSchema.parse(responseOutputTextLogprob));
 }
-export function logprobFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Logprob$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Logprob' from JSON`);
+export function responseOutputTextLogprobFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ResponseOutputTextLogprob$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponseOutputTextLogprob' from JSON`);
 }
 /** @internal */
 export const ResponseOutputText$inboundSchema = z.object({
     type: z.literal("output_text"),
     text: z.string(),
     annotations: z.array(OpenAIResponsesAnnotation$inboundSchema).optional(),
-    logprobs: z.array(z.lazy(() => Logprob$inboundSchema)).optional(),
+    logprobs: z.array(z.lazy(() => ResponseOutputTextLogprob$inboundSchema))
+        .optional(),
 });
 /** @internal */
 export const ResponseOutputText$outboundSchema = z.object({
     type: z.literal("output_text"),
     text: z.string(),
     annotations: z.array(OpenAIResponsesAnnotation$outboundSchema).optional(),
-    logprobs: z.array(z.lazy(() => Logprob$outboundSchema)).optional(),
+    logprobs: z.array(z.lazy(() => ResponseOutputTextLogprob$outboundSchema))
+        .optional(),
 });
 export function responseOutputTextToJSON(responseOutputText) {
     return JSON.stringify(ResponseOutputText$outboundSchema.parse(responseOutputText));

package/esm/models/responseserrorfield.d.ts

@@ -2,7 +2,7 @@ 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 CodeEnum: {
+export declare const Code: {
     readonly ServerError: "server_error";
     readonly RateLimitExceeded: "rate_limit_exceeded";
     readonly InvalidPrompt: "invalid_prompt";
@@ -22,16 +22,16 @@ export declare const CodeEnum: {
     readonly FailedToDownloadImage: "failed_to_download_image";
     readonly ImageFileNotFound: "image_file_not_found";
 };
-export type CodeEnum = OpenEnum<typeof CodeEnum>;
+export type Code = OpenEnum<typeof Code>;
 /**
  * Error information returned from the API
  */
 export type ResponsesErrorField = {
-    code: CodeEnum;
+    code: Code;
     message: string;
 };
 /** @internal */
-export declare const CodeEnum$inboundSchema: z.ZodType<CodeEnum, unknown>;
+export declare const Code$inboundSchema: z.ZodType<Code, unknown>;
 /** @internal */
 export declare const ResponsesErrorField$inboundSchema: z.ZodType<ResponsesErrorField, unknown>;
 export declare function responsesErrorFieldFromJSON(jsonString: string): SafeParseResult<ResponsesErrorField, SDKValidationError>;

package/esm/models/responseserrorfield.js

@@ -5,7 +5,7 @@
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 import * as openEnums from "../types/enums.js";
-export const CodeEnum = {
+export const Code = {
     ServerError: "server_error",
     RateLimitExceeded: "rate_limit_exceeded",
     InvalidPrompt: "invalid_prompt",
@@ -26,11 +26,11 @@ export const CodeEnum = {
     ImageFileNotFound: "image_file_not_found",
 };
 /** @internal */
-export const CodeEnum$inboundSchema = openEnums
-    .inboundSchema(CodeEnum);
+export const Code$inboundSchema = openEnums
+    .inboundSchema(Code);
 /** @internal */
 export const ResponsesErrorField$inboundSchema = z.object({
-    code: CodeEnum$inboundSchema,
+    code: Code$inboundSchema,
     message: z.string(),
 });
 export function responsesErrorFieldFromJSON(jsonString) {

package/esm/models/responsesoutputitem.d.ts

@@ -6,23 +6,12 @@ import { ResponsesOutputItemFileSearchCall } from "./responsesoutputitemfilesear
 import { ResponsesOutputItemFunctionCall } from "./responsesoutputitemfunctioncall.js";
 import { ResponsesOutputItemReasoning } from "./responsesoutputitemreasoning.js";
 import { ResponsesOutputMessage } from "./responsesoutputmessage.js";
+import { ResponsesServerToolOutput } from "./responsesservertooloutput.js";
 import { ResponsesWebSearchCallOutput } from "./responseswebsearchcalloutput.js";
 /**
  * An output item from the response
  */
-export type ResponsesOutputItem = (ResponsesOutputMessage & {
-    type: "message";
-}) | (ResponsesOutputItemReasoning & {
-    type: "reasoning";
-}) | (ResponsesOutputItemFunctionCall & {
-    type: "function_call";
-}) | (ResponsesWebSearchCallOutput & {
-    type: "web_search_call";
-}) | (ResponsesOutputItemFileSearchCall & {
-    type: "file_search_call";
-}) | (ResponsesImageGenerationCall & {
-    type: "image_generation_call";
-});
+export type ResponsesOutputItem = ResponsesOutputMessage | ResponsesOutputItemFunctionCall | ResponsesWebSearchCallOutput | ResponsesOutputItemFileSearchCall | ResponsesOutputItemReasoning | ResponsesImageGenerationCall | ResponsesServerToolOutput;
 /** @internal */
 export declare const ResponsesOutputItem$inboundSchema: z.ZodType<ResponsesOutputItem, unknown>;
 export declare function responsesOutputItemFromJSON(jsonString: string): SafeParseResult<ResponsesOutputItem, SDKValidationError>;

package/esm/models/responsesoutputitem.js

@@ -9,15 +9,17 @@ import { ResponsesOutputItemFileSearchCall$inboundSchema, } from "./responsesout
 import { ResponsesOutputItemFunctionCall$inboundSchema, } from "./responsesoutputitemfunctioncall.js";
 import { ResponsesOutputItemReasoning$inboundSchema, } from "./responsesoutputitemreasoning.js";
 import { ResponsesOutputMessage$inboundSchema, } from "./responsesoutputmessage.js";
+import { ResponsesServerToolOutput$inboundSchema, } from "./responsesservertooloutput.js";
 import { ResponsesWebSearchCallOutput$inboundSchema, } from "./responseswebsearchcalloutput.js";
 /** @internal */
 export const ResponsesOutputItem$inboundSchema = z.union([
-    ResponsesOutputMessage$inboundSchema.and(z.object({ type: z.literal("message") })),
-    ResponsesOutputItemReasoning$inboundSchema.and(z.object({ type: z.literal("reasoning") })),
-    ResponsesOutputItemFunctionCall$inboundSchema.and(z.object({ type: z.literal("function_call") })),
-    ResponsesWebSearchCallOutput$inboundSchema.and(z.object({ type: z.literal("web_search_call") })),
-    ResponsesOutputItemFileSearchCall$inboundSchema.and(z.object({ type: z.literal("file_search_call") })),
-    ResponsesImageGenerationCall$inboundSchema.and(z.object({ type: z.literal("image_generation_call") })),
+    ResponsesOutputMessage$inboundSchema,
+    ResponsesOutputItemFunctionCall$inboundSchema,
+    ResponsesWebSearchCallOutput$inboundSchema,
+    ResponsesOutputItemFileSearchCall$inboundSchema,
+    ResponsesOutputItemReasoning$inboundSchema,
+    ResponsesImageGenerationCall$inboundSchema,
+    ResponsesServerToolOutput$inboundSchema,
 ]);
 export function responsesOutputItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ResponsesOutputItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponsesOutputItem' from JSON`);