@openrouter/sdk 0.8.0 → 0.10.2

package/esm/models/openresponsesinputmessageitem.js

@@ -78,13 +78,13 @@ export const OpenResponsesInputMessageItem$outboundSchema = z.object({
         OpenResponsesInputMessageItemRoleSystem$outboundSchema,
         OpenResponsesInputMessageItemRoleDeveloper$outboundSchema,
     ]),
-    content: z.array(z.union([
+    content: z.nullable(z.array(z.union([
         ResponseInputText$outboundSchema,
         z.lazy(() => OpenResponsesInputMessageItemContentInputImage$outboundSchema),
         ResponseInputFile$outboundSchema,
         ResponseInputAudio$outboundSchema,
         ResponseInputVideo$outboundSchema,
-    ])),
+    ]))).optional(),
 });
 export function openResponsesInputMessageItemToJSON(openResponsesInputMessageItem) {
     return JSON.stringify(OpenResponsesInputMessageItem$outboundSchema.parse(openResponsesInputMessageItem));

package/esm/models/openresponsesinputunion.d.ts

@@ -0,0 +1,207 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { OpenAIResponsesRefusalContent, OpenAIResponsesRefusalContent$Outbound } from "./openairesponsesrefusalcontent.js";
+import { OpenResponsesEasyInputMessage, OpenResponsesEasyInputMessage$Outbound } from "./openresponseseasyinputmessage.js";
+import { OpenResponsesFunctionCallOutput, OpenResponsesFunctionCallOutput$Outbound } from "./openresponsesfunctioncalloutput.js";
+import { OpenResponsesFunctionToolCall, OpenResponsesFunctionToolCall$Outbound } from "./openresponsesfunctiontoolcall.js";
+import { OpenResponsesInputMessageItem, OpenResponsesInputMessageItem$Outbound } from "./openresponsesinputmessageitem.js";
+import { OpenResponsesReasoning, OpenResponsesReasoning$Outbound } from "./openresponsesreasoning.js";
+import { ReasoningSummaryText, ReasoningSummaryText$Outbound } from "./reasoningsummarytext.js";
+import { ReasoningTextContent, ReasoningTextContent$Outbound } from "./reasoningtextcontent.js";
+import { ResponseOutputText, ResponseOutputText$Outbound } from "./responseoutputtext.js";
+import { ResponsesImageGenerationCall, ResponsesImageGenerationCall$Outbound } from "./responsesimagegenerationcall.js";
+import { ResponsesOutputItemFileSearchCall, ResponsesOutputItemFileSearchCall$Outbound } from "./responsesoutputitemfilesearchcall.js";
+import { ResponsesOutputItemFunctionCall, ResponsesOutputItemFunctionCall$Outbound } from "./responsesoutputitemfunctioncall.js";
+import { ResponsesServerToolOutput, ResponsesServerToolOutput$Outbound } from "./responsesservertooloutput.js";
+import { ResponsesWebSearchCallOutput, ResponsesWebSearchCallOutput$Outbound } from "./responseswebsearchcalloutput.js";
+export declare const OpenResponsesInputTypeReasoning: {
+    readonly Reasoning: "reasoning";
+};
+export type OpenResponsesInputTypeReasoning = ClosedEnum<typeof OpenResponsesInputTypeReasoning>;
+export declare const OpenResponsesInputStatusInProgress2: {
+    readonly InProgress: "in_progress";
+};
+export type OpenResponsesInputStatusInProgress2 = ClosedEnum<typeof OpenResponsesInputStatusInProgress2>;
+export declare const OpenResponsesInputStatusIncomplete2: {
+    readonly Incomplete: "incomplete";
+};
+export type OpenResponsesInputStatusIncomplete2 = ClosedEnum<typeof OpenResponsesInputStatusIncomplete2>;
+export declare const OpenResponsesInputStatusCompleted2: {
+    readonly Completed: "completed";
+};
+export type OpenResponsesInputStatusCompleted2 = ClosedEnum<typeof OpenResponsesInputStatusCompleted2>;
+export type OpenResponsesInputStatusUnion2 = OpenResponsesInputStatusCompleted2 | OpenResponsesInputStatusIncomplete2 | OpenResponsesInputStatusInProgress2;
+/**
+ * The format of the reasoning content
+ */
+export declare const OpenResponsesInputFormat: {
+    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";
+};
+/**
+ * The format of the reasoning content
+ */
+export type OpenResponsesInputFormat = OpenEnum<typeof OpenResponsesInputFormat>;
+/**
+ * An output item containing reasoning
+ */
+export type OpenResponsesInputReasoning = {
+    type: OpenResponsesInputTypeReasoning;
+    id: string;
+    content?: Array<ReasoningTextContent> | null | undefined;
+    summary: Array<ReasoningSummaryText> | null;
+    encryptedContent?: string | null | undefined;
+    status?: OpenResponsesInputStatusCompleted2 | OpenResponsesInputStatusIncomplete2 | OpenResponsesInputStatusInProgress2 | undefined;
+    /**
+     * A signature for the reasoning content, used for verification
+     */
+    signature?: string | null | undefined;
+    /**
+     * The format of the reasoning content
+     */
+    format?: OpenResponsesInputFormat | null | undefined;
+};
+export declare const OpenResponsesInputRole: {
+    readonly Assistant: "assistant";
+};
+export type OpenResponsesInputRole = ClosedEnum<typeof OpenResponsesInputRole>;
+export declare const OpenResponsesInputTypeMessage: {
+    readonly Message: "message";
+};
+export type OpenResponsesInputTypeMessage = ClosedEnum<typeof OpenResponsesInputTypeMessage>;
+export declare const OpenResponsesInputStatusInProgress1: {
+    readonly InProgress: "in_progress";
+};
+export type OpenResponsesInputStatusInProgress1 = ClosedEnum<typeof OpenResponsesInputStatusInProgress1>;
+export declare const OpenResponsesInputStatusIncomplete1: {
+    readonly Incomplete: "incomplete";
+};
+export type OpenResponsesInputStatusIncomplete1 = ClosedEnum<typeof OpenResponsesInputStatusIncomplete1>;
+export declare const OpenResponsesInputStatusCompleted1: {
+    readonly Completed: "completed";
+};
+export type OpenResponsesInputStatusCompleted1 = ClosedEnum<typeof OpenResponsesInputStatusCompleted1>;
+export type OpenResponsesInputStatusUnion1 = OpenResponsesInputStatusCompleted1 | OpenResponsesInputStatusIncomplete1 | OpenResponsesInputStatusInProgress1;
+export type OpenResponsesInputContent1 = ResponseOutputText | OpenAIResponsesRefusalContent;
+export type OpenResponsesInputContent2 = Array<ResponseOutputText | OpenAIResponsesRefusalContent> | string | any;
+export declare const OpenResponsesInputPhaseFinalAnswer: {
+    readonly FinalAnswer: "final_answer";
+};
+export type OpenResponsesInputPhaseFinalAnswer = ClosedEnum<typeof OpenResponsesInputPhaseFinalAnswer>;
+export declare const OpenResponsesInputPhaseCommentary: {
+    readonly Commentary: "commentary";
+};
+export type OpenResponsesInputPhaseCommentary = ClosedEnum<typeof OpenResponsesInputPhaseCommentary>;
+/**
+ * The phase of an assistant message. Use `commentary` for an intermediate assistant message and `final_answer` for the final assistant message. For follow-up requests with models like `gpt-5.3-codex` and later, preserve and resend phase on all assistant messages. Omitting it can degrade performance. Not used for user messages.
+ */
+export type OpenResponsesInputPhaseUnion = OpenResponsesInputPhaseCommentary | OpenResponsesInputPhaseFinalAnswer | any;
+/**
+ * An output message item
+ */
+export type OpenResponsesInputMessage = {
+    id: string;
+    role: OpenResponsesInputRole;
+    type: OpenResponsesInputTypeMessage;
+    status?: OpenResponsesInputStatusCompleted1 | OpenResponsesInputStatusIncomplete1 | OpenResponsesInputStatusInProgress1 | undefined;
+    content?: Array<ResponseOutputText | OpenAIResponsesRefusalContent> | string | any | null | undefined;
+    /**
+     * The phase of an assistant message. Use `commentary` for an intermediate assistant message and `final_answer` for the final assistant message. For follow-up requests with models like `gpt-5.3-codex` and later, preserve and resend phase on all assistant messages. Omitting it can degrade performance. Not used for user messages.
+     */
+    phase?: OpenResponsesInputPhaseCommentary | OpenResponsesInputPhaseFinalAnswer | any | null | undefined;
+};
+export type OpenResponsesInputUnion1 = OpenResponsesFunctionToolCall | OpenResponsesInputMessage | ResponsesOutputItemFunctionCall | ResponsesWebSearchCallOutput | ResponsesOutputItemFileSearchCall | OpenResponsesReasoning | OpenResponsesFunctionCallOutput | OpenResponsesInputReasoning | ResponsesImageGenerationCall | ResponsesServerToolOutput | OpenResponsesEasyInputMessage | OpenResponsesInputMessageItem;
+/**
+ * Input for a response request - can be a string or array of items
+ */
+export type OpenResponsesInputUnion = string | Array<OpenResponsesFunctionToolCall | OpenResponsesInputMessage | ResponsesOutputItemFunctionCall | ResponsesWebSearchCallOutput | ResponsesOutputItemFileSearchCall | OpenResponsesReasoning | OpenResponsesFunctionCallOutput | OpenResponsesInputReasoning | ResponsesImageGenerationCall | ResponsesServerToolOutput | OpenResponsesEasyInputMessage | OpenResponsesInputMessageItem>;
+/** @internal */
+export declare const OpenResponsesInputTypeReasoning$outboundSchema: z.ZodEnum<typeof OpenResponsesInputTypeReasoning>;
+/** @internal */
+export declare const OpenResponsesInputStatusInProgress2$outboundSchema: z.ZodEnum<typeof OpenResponsesInputStatusInProgress2>;
+/** @internal */
+export declare const OpenResponsesInputStatusIncomplete2$outboundSchema: z.ZodEnum<typeof OpenResponsesInputStatusIncomplete2>;
+/** @internal */
+export declare const OpenResponsesInputStatusCompleted2$outboundSchema: z.ZodEnum<typeof OpenResponsesInputStatusCompleted2>;
+/** @internal */
+export type OpenResponsesInputStatusUnion2$Outbound = string | string | string;
+/** @internal */
+export declare const OpenResponsesInputStatusUnion2$outboundSchema: z.ZodType<OpenResponsesInputStatusUnion2$Outbound, OpenResponsesInputStatusUnion2>;
+export declare function openResponsesInputStatusUnion2ToJSON(openResponsesInputStatusUnion2: OpenResponsesInputStatusUnion2): string;
+/** @internal */
+export declare const OpenResponsesInputFormat$outboundSchema: z.ZodType<string, OpenResponsesInputFormat>;
+/** @internal */
+export type OpenResponsesInputReasoning$Outbound = {
+    type: string;
+    id: string;
+    content?: Array<ReasoningTextContent$Outbound> | null | undefined;
+    summary: Array<ReasoningSummaryText$Outbound> | null;
+    encrypted_content?: string | null | undefined;
+    status?: string | string | string | undefined;
+    signature?: string | null | undefined;
+    format?: string | null | undefined;
+};
+/** @internal */
+export declare const OpenResponsesInputReasoning$outboundSchema: z.ZodType<OpenResponsesInputReasoning$Outbound, OpenResponsesInputReasoning>;
+export declare function openResponsesInputReasoningToJSON(openResponsesInputReasoning: OpenResponsesInputReasoning): string;
+/** @internal */
+export declare const OpenResponsesInputRole$outboundSchema: z.ZodEnum<typeof OpenResponsesInputRole>;
+/** @internal */
+export declare const OpenResponsesInputTypeMessage$outboundSchema: z.ZodEnum<typeof OpenResponsesInputTypeMessage>;
+/** @internal */
+export declare const OpenResponsesInputStatusInProgress1$outboundSchema: z.ZodEnum<typeof OpenResponsesInputStatusInProgress1>;
+/** @internal */
+export declare const OpenResponsesInputStatusIncomplete1$outboundSchema: z.ZodEnum<typeof OpenResponsesInputStatusIncomplete1>;
+/** @internal */
+export declare const OpenResponsesInputStatusCompleted1$outboundSchema: z.ZodEnum<typeof OpenResponsesInputStatusCompleted1>;
+/** @internal */
+export type OpenResponsesInputStatusUnion1$Outbound = string | string | string;
+/** @internal */
+export declare const OpenResponsesInputStatusUnion1$outboundSchema: z.ZodType<OpenResponsesInputStatusUnion1$Outbound, OpenResponsesInputStatusUnion1>;
+export declare function openResponsesInputStatusUnion1ToJSON(openResponsesInputStatusUnion1: OpenResponsesInputStatusUnion1): string;
+/** @internal */
+export type OpenResponsesInputContent1$Outbound = ResponseOutputText$Outbound | OpenAIResponsesRefusalContent$Outbound;
+/** @internal */
+export declare const OpenResponsesInputContent1$outboundSchema: z.ZodType<OpenResponsesInputContent1$Outbound, OpenResponsesInputContent1>;
+export declare function openResponsesInputContent1ToJSON(openResponsesInputContent1: OpenResponsesInputContent1): string;
+/** @internal */
+export type OpenResponsesInputContent2$Outbound = Array<ResponseOutputText$Outbound | OpenAIResponsesRefusalContent$Outbound> | string | any;
+/** @internal */
+export declare const OpenResponsesInputContent2$outboundSchema: z.ZodType<OpenResponsesInputContent2$Outbound, OpenResponsesInputContent2>;
+export declare function openResponsesInputContent2ToJSON(openResponsesInputContent2: OpenResponsesInputContent2): string;
+/** @internal */
+export declare const OpenResponsesInputPhaseFinalAnswer$outboundSchema: z.ZodEnum<typeof OpenResponsesInputPhaseFinalAnswer>;
+/** @internal */
+export declare const OpenResponsesInputPhaseCommentary$outboundSchema: z.ZodEnum<typeof OpenResponsesInputPhaseCommentary>;
+/** @internal */
+export type OpenResponsesInputPhaseUnion$Outbound = string | string | any;
+/** @internal */
+export declare const OpenResponsesInputPhaseUnion$outboundSchema: z.ZodType<OpenResponsesInputPhaseUnion$Outbound, OpenResponsesInputPhaseUnion>;
+export declare function openResponsesInputPhaseUnionToJSON(openResponsesInputPhaseUnion: OpenResponsesInputPhaseUnion): string;
+/** @internal */
+export type OpenResponsesInputMessage$Outbound = {
+    id: string;
+    role: string;
+    type: string;
+    status?: string | string | string | undefined;
+    content?: Array<ResponseOutputText$Outbound | OpenAIResponsesRefusalContent$Outbound> | string | any | null | undefined;
+    phase?: string | string | any | null | undefined;
+};
+/** @internal */
+export declare const OpenResponsesInputMessage$outboundSchema: z.ZodType<OpenResponsesInputMessage$Outbound, OpenResponsesInputMessage>;
+export declare function openResponsesInputMessageToJSON(openResponsesInputMessage: OpenResponsesInputMessage): string;
+/** @internal */
+export type OpenResponsesInputUnion1$Outbound = OpenResponsesFunctionToolCall$Outbound | OpenResponsesInputMessage$Outbound | ResponsesOutputItemFunctionCall$Outbound | ResponsesWebSearchCallOutput$Outbound | ResponsesOutputItemFileSearchCall$Outbound | OpenResponsesReasoning$Outbound | OpenResponsesFunctionCallOutput$Outbound | OpenResponsesInputReasoning$Outbound | ResponsesImageGenerationCall$Outbound | ResponsesServerToolOutput$Outbound | OpenResponsesEasyInputMessage$Outbound | OpenResponsesInputMessageItem$Outbound;
+/** @internal */
+export declare const OpenResponsesInputUnion1$outboundSchema: z.ZodType<OpenResponsesInputUnion1$Outbound, OpenResponsesInputUnion1>;
+export declare function openResponsesInputUnion1ToJSON(openResponsesInputUnion1: OpenResponsesInputUnion1): string;
+/** @internal */
+export type OpenResponsesInputUnion$Outbound = string | Array<OpenResponsesFunctionToolCall$Outbound | OpenResponsesInputMessage$Outbound | ResponsesOutputItemFunctionCall$Outbound | ResponsesWebSearchCallOutput$Outbound | ResponsesOutputItemFileSearchCall$Outbound | OpenResponsesReasoning$Outbound | OpenResponsesFunctionCallOutput$Outbound | OpenResponsesInputReasoning$Outbound | ResponsesImageGenerationCall$Outbound | ResponsesServerToolOutput$Outbound | OpenResponsesEasyInputMessage$Outbound | OpenResponsesInputMessageItem$Outbound>;
+/** @internal */
+export declare const OpenResponsesInputUnion$outboundSchema: z.ZodType<OpenResponsesInputUnion$Outbound, OpenResponsesInputUnion>;
+export declare function openResponsesInputUnionToJSON(openResponsesInputUnion: OpenResponsesInputUnion): string;
+//# sourceMappingURL=openresponsesinputunion.d.ts.map

package/esm/models/openresponsesinputunion.js

@@ -0,0 +1,225 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: b2182cf1a268
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+import { OpenAIResponsesRefusalContent$outboundSchema, } from "./openairesponsesrefusalcontent.js";
+import { OpenResponsesEasyInputMessage$outboundSchema, } from "./openresponseseasyinputmessage.js";
+import { OpenResponsesFunctionCallOutput$outboundSchema, } from "./openresponsesfunctioncalloutput.js";
+import { OpenResponsesFunctionToolCall$outboundSchema, } from "./openresponsesfunctiontoolcall.js";
+import { OpenResponsesInputMessageItem$outboundSchema, } from "./openresponsesinputmessageitem.js";
+import { OpenResponsesReasoning$outboundSchema, } from "./openresponsesreasoning.js";
+import { ReasoningSummaryText$outboundSchema, } from "./reasoningsummarytext.js";
+import { ReasoningTextContent$outboundSchema, } from "./reasoningtextcontent.js";
+import { ResponseOutputText$outboundSchema, } from "./responseoutputtext.js";
+import { ResponsesImageGenerationCall$outboundSchema, } from "./responsesimagegenerationcall.js";
+import { ResponsesOutputItemFileSearchCall$outboundSchema, } from "./responsesoutputitemfilesearchcall.js";
+import { ResponsesOutputItemFunctionCall$outboundSchema, } from "./responsesoutputitemfunctioncall.js";
+import { ResponsesServerToolOutput$outboundSchema, } from "./responsesservertooloutput.js";
+import { ResponsesWebSearchCallOutput$outboundSchema, } from "./responseswebsearchcalloutput.js";
+export const OpenResponsesInputTypeReasoning = {
+    Reasoning: "reasoning",
+};
+export const OpenResponsesInputStatusInProgress2 = {
+    InProgress: "in_progress",
+};
+export const OpenResponsesInputStatusIncomplete2 = {
+    Incomplete: "incomplete",
+};
+export const OpenResponsesInputStatusCompleted2 = {
+    Completed: "completed",
+};
+/**
+ * The format of the reasoning content
+ */
+export const OpenResponsesInputFormat = {
+    Unknown: "unknown",
+    OpenaiResponsesV1: "openai-responses-v1",
+    AzureOpenaiResponsesV1: "azure-openai-responses-v1",
+    XaiResponsesV1: "xai-responses-v1",
+    AnthropicClaudeV1: "anthropic-claude-v1",
+    GoogleGeminiV1: "google-gemini-v1",
+};
+export const OpenResponsesInputRole = {
+    Assistant: "assistant",
+};
+export const OpenResponsesInputTypeMessage = {
+    Message: "message",
+};
+export const OpenResponsesInputStatusInProgress1 = {
+    InProgress: "in_progress",
+};
+export const OpenResponsesInputStatusIncomplete1 = {
+    Incomplete: "incomplete",
+};
+export const OpenResponsesInputStatusCompleted1 = {
+    Completed: "completed",
+};
+export const OpenResponsesInputPhaseFinalAnswer = {
+    FinalAnswer: "final_answer",
+};
+export const OpenResponsesInputPhaseCommentary = {
+    Commentary: "commentary",
+};
+/** @internal */
+export const OpenResponsesInputTypeReasoning$outboundSchema = z.enum(OpenResponsesInputTypeReasoning);
+/** @internal */
+export const OpenResponsesInputStatusInProgress2$outboundSchema = z.enum(OpenResponsesInputStatusInProgress2);
+/** @internal */
+export const OpenResponsesInputStatusIncomplete2$outboundSchema = z.enum(OpenResponsesInputStatusIncomplete2);
+/** @internal */
+export const OpenResponsesInputStatusCompleted2$outboundSchema = z.enum(OpenResponsesInputStatusCompleted2);
+/** @internal */
+export const OpenResponsesInputStatusUnion2$outboundSchema = z.union([
+    OpenResponsesInputStatusCompleted2$outboundSchema,
+    OpenResponsesInputStatusIncomplete2$outboundSchema,
+    OpenResponsesInputStatusInProgress2$outboundSchema,
+]);
+export function openResponsesInputStatusUnion2ToJSON(openResponsesInputStatusUnion2) {
+    return JSON.stringify(OpenResponsesInputStatusUnion2$outboundSchema.parse(openResponsesInputStatusUnion2));
+}
+/** @internal */
+export const OpenResponsesInputFormat$outboundSchema = openEnums.outboundSchema(OpenResponsesInputFormat);
+/** @internal */
+export const OpenResponsesInputReasoning$outboundSchema = z.object({
+    type: OpenResponsesInputTypeReasoning$outboundSchema,
+    id: z.string(),
+    content: z.nullable(z.array(ReasoningTextContent$outboundSchema)).optional(),
+    summary: z.nullable(z.array(ReasoningSummaryText$outboundSchema)),
+    encryptedContent: z.nullable(z.string()).optional(),
+    status: z.union([
+        OpenResponsesInputStatusCompleted2$outboundSchema,
+        OpenResponsesInputStatusIncomplete2$outboundSchema,
+        OpenResponsesInputStatusInProgress2$outboundSchema,
+    ]).optional(),
+    signature: z.nullable(z.string()).optional(),
+    format: z.nullable(OpenResponsesInputFormat$outboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        encryptedContent: "encrypted_content",
+    });
+});
+export function openResponsesInputReasoningToJSON(openResponsesInputReasoning) {
+    return JSON.stringify(OpenResponsesInputReasoning$outboundSchema.parse(openResponsesInputReasoning));
+}
+/** @internal */
+export const OpenResponsesInputRole$outboundSchema = z.enum(OpenResponsesInputRole);
+/** @internal */
+export const OpenResponsesInputTypeMessage$outboundSchema = z.enum(OpenResponsesInputTypeMessage);
+/** @internal */
+export const OpenResponsesInputStatusInProgress1$outboundSchema = z.enum(OpenResponsesInputStatusInProgress1);
+/** @internal */
+export const OpenResponsesInputStatusIncomplete1$outboundSchema = z.enum(OpenResponsesInputStatusIncomplete1);
+/** @internal */
+export const OpenResponsesInputStatusCompleted1$outboundSchema = z.enum(OpenResponsesInputStatusCompleted1);
+/** @internal */
+export const OpenResponsesInputStatusUnion1$outboundSchema = z.union([
+    OpenResponsesInputStatusCompleted1$outboundSchema,
+    OpenResponsesInputStatusIncomplete1$outboundSchema,
+    OpenResponsesInputStatusInProgress1$outboundSchema,
+]);
+export function openResponsesInputStatusUnion1ToJSON(openResponsesInputStatusUnion1) {
+    return JSON.stringify(OpenResponsesInputStatusUnion1$outboundSchema.parse(openResponsesInputStatusUnion1));
+}
+/** @internal */
+export const OpenResponsesInputContent1$outboundSchema = z.union([
+    ResponseOutputText$outboundSchema,
+    OpenAIResponsesRefusalContent$outboundSchema,
+]);
+export function openResponsesInputContent1ToJSON(openResponsesInputContent1) {
+    return JSON.stringify(OpenResponsesInputContent1$outboundSchema.parse(openResponsesInputContent1));
+}
+/** @internal */
+export const OpenResponsesInputContent2$outboundSchema = z.union([
+    z.array(z.union([
+        ResponseOutputText$outboundSchema,
+        OpenAIResponsesRefusalContent$outboundSchema,
+    ])),
+    z.string(),
+    z.any(),
+]);
+export function openResponsesInputContent2ToJSON(openResponsesInputContent2) {
+    return JSON.stringify(OpenResponsesInputContent2$outboundSchema.parse(openResponsesInputContent2));
+}
+/** @internal */
+export const OpenResponsesInputPhaseFinalAnswer$outboundSchema = z.enum(OpenResponsesInputPhaseFinalAnswer);
+/** @internal */
+export const OpenResponsesInputPhaseCommentary$outboundSchema = z.enum(OpenResponsesInputPhaseCommentary);
+/** @internal */
+export const OpenResponsesInputPhaseUnion$outboundSchema = z.union([
+    OpenResponsesInputPhaseCommentary$outboundSchema,
+    OpenResponsesInputPhaseFinalAnswer$outboundSchema,
+    z.any(),
+]);
+export function openResponsesInputPhaseUnionToJSON(openResponsesInputPhaseUnion) {
+    return JSON.stringify(OpenResponsesInputPhaseUnion$outboundSchema.parse(openResponsesInputPhaseUnion));
+}
+/** @internal */
+export const OpenResponsesInputMessage$outboundSchema = z.object({
+    id: z.string(),
+    role: OpenResponsesInputRole$outboundSchema,
+    type: OpenResponsesInputTypeMessage$outboundSchema,
+    status: z.union([
+        OpenResponsesInputStatusCompleted1$outboundSchema,
+        OpenResponsesInputStatusIncomplete1$outboundSchema,
+        OpenResponsesInputStatusInProgress1$outboundSchema,
+    ]).optional(),
+    content: z.nullable(z.union([
+        z.array(z.union([
+            ResponseOutputText$outboundSchema,
+            OpenAIResponsesRefusalContent$outboundSchema,
+        ])),
+        z.string(),
+        z.any(),
+    ])).optional(),
+    phase: z.nullable(z.union([
+        OpenResponsesInputPhaseCommentary$outboundSchema,
+        OpenResponsesInputPhaseFinalAnswer$outboundSchema,
+        z.any(),
+    ])).optional(),
+});
+export function openResponsesInputMessageToJSON(openResponsesInputMessage) {
+    return JSON.stringify(OpenResponsesInputMessage$outboundSchema.parse(openResponsesInputMessage));
+}
+/** @internal */
+export const OpenResponsesInputUnion1$outboundSchema = z.union([
+    OpenResponsesFunctionToolCall$outboundSchema,
+    z.lazy(() => OpenResponsesInputMessage$outboundSchema),
+    ResponsesOutputItemFunctionCall$outboundSchema,
+    ResponsesWebSearchCallOutput$outboundSchema,
+    ResponsesOutputItemFileSearchCall$outboundSchema,
+    OpenResponsesReasoning$outboundSchema,
+    OpenResponsesFunctionCallOutput$outboundSchema,
+    z.lazy(() => OpenResponsesInputReasoning$outboundSchema),
+    ResponsesImageGenerationCall$outboundSchema,
+    ResponsesServerToolOutput$outboundSchema,
+    OpenResponsesEasyInputMessage$outboundSchema,
+    OpenResponsesInputMessageItem$outboundSchema,
+]);
+export function openResponsesInputUnion1ToJSON(openResponsesInputUnion1) {
+    return JSON.stringify(OpenResponsesInputUnion1$outboundSchema.parse(openResponsesInputUnion1));
+}
+/** @internal */
+export const OpenResponsesInputUnion$outboundSchema = z.union([
+    z.string(),
+    z.array(z.union([
+        OpenResponsesFunctionToolCall$outboundSchema,
+        z.lazy(() => OpenResponsesInputMessage$outboundSchema),
+        ResponsesOutputItemFunctionCall$outboundSchema,
+        ResponsesWebSearchCallOutput$outboundSchema,
+        ResponsesOutputItemFileSearchCall$outboundSchema,
+        OpenResponsesReasoning$outboundSchema,
+        OpenResponsesFunctionCallOutput$outboundSchema,
+        z.lazy(() => OpenResponsesInputReasoning$outboundSchema),
+        ResponsesImageGenerationCall$outboundSchema,
+        ResponsesServerToolOutput$outboundSchema,
+        OpenResponsesEasyInputMessage$outboundSchema,
+        OpenResponsesInputMessageItem$outboundSchema,
+    ])),
+]);
+export function openResponsesInputUnionToJSON(openResponsesInputUnion) {
+    return JSON.stringify(OpenResponsesInputUnion$outboundSchema.parse(openResponsesInputUnion));
+}
+//# sourceMappingURL=openresponsesinputunion.js.map

package/esm/models/openresponseslocalshelltool.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";
+/**
+ * Local shell tool configuration
+ */
+export type OpenResponsesLocalShellTool = {
+    type: "local_shell";
+};
+/** @internal */
+export declare const OpenResponsesLocalShellTool$inboundSchema: z.ZodType<OpenResponsesLocalShellTool, unknown>;
+/** @internal */
+export type OpenResponsesLocalShellTool$Outbound = {
+    type: "local_shell";
+};
+/** @internal */
+export declare const OpenResponsesLocalShellTool$outboundSchema: z.ZodType<OpenResponsesLocalShellTool$Outbound, OpenResponsesLocalShellTool>;
+export declare function openResponsesLocalShellToolToJSON(openResponsesLocalShellTool: OpenResponsesLocalShellTool): string;
+export declare function openResponsesLocalShellToolFromJSON(jsonString: string): SafeParseResult<OpenResponsesLocalShellTool, SDKValidationError>;
+//# sourceMappingURL=openresponseslocalshelltool.d.ts.map

package/esm/models/openresponseslocalshelltool.js

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

package/esm/models/openresponsesmcptool.d.ts

@@ -0,0 +1,128 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AllowedTools = {
+    toolNames?: Array<string> | undefined;
+    readOnly?: boolean | undefined;
+};
+export declare const ConnectorId: {
+    readonly ConnectorDropbox: "connector_dropbox";
+    readonly ConnectorGmail: "connector_gmail";
+    readonly ConnectorGooglecalendar: "connector_googlecalendar";
+    readonly ConnectorGoogledrive: "connector_googledrive";
+    readonly ConnectorMicrosoftteams: "connector_microsoftteams";
+    readonly ConnectorOutlookcalendar: "connector_outlookcalendar";
+    readonly ConnectorOutlookemail: "connector_outlookemail";
+    readonly ConnectorSharepoint: "connector_sharepoint";
+};
+export type ConnectorId = OpenEnum<typeof ConnectorId>;
+export declare const RequireApprovalNever: {
+    readonly Never: "never";
+};
+export type RequireApprovalNever = ClosedEnum<typeof RequireApprovalNever>;
+export declare const RequireApprovalAlways: {
+    readonly Always: "always";
+};
+export type RequireApprovalAlways = ClosedEnum<typeof RequireApprovalAlways>;
+export type Never = {
+    toolNames?: Array<string> | undefined;
+};
+export type Always = {
+    toolNames?: Array<string> | undefined;
+};
+export type RequireApproval = {
+    never?: Never | undefined;
+    always?: Always | undefined;
+};
+/**
+ * MCP (Model Context Protocol) tool configuration
+ */
+export type OpenResponsesMcpTool = {
+    type: "mcp";
+    serverLabel: string;
+    allowedTools?: any | null | undefined;
+    authorization?: string | undefined;
+    connectorId?: ConnectorId | undefined;
+    headers?: {
+        [k: string]: string;
+    } | null | undefined;
+    requireApproval?: any | null | undefined;
+    serverDescription?: string | undefined;
+    serverUrl?: string | undefined;
+};
+/** @internal */
+export declare const AllowedTools$inboundSchema: z.ZodType<AllowedTools, unknown>;
+/** @internal */
+export type AllowedTools$Outbound = {
+    tool_names?: Array<string> | undefined;
+    read_only?: boolean | undefined;
+};
+/** @internal */
+export declare const AllowedTools$outboundSchema: z.ZodType<AllowedTools$Outbound, AllowedTools>;
+export declare function allowedToolsToJSON(allowedTools: AllowedTools): string;
+export declare function allowedToolsFromJSON(jsonString: string): SafeParseResult<AllowedTools, SDKValidationError>;
+/** @internal */
+export declare const ConnectorId$inboundSchema: z.ZodType<ConnectorId, unknown>;
+/** @internal */
+export declare const ConnectorId$outboundSchema: z.ZodType<string, ConnectorId>;
+/** @internal */
+export declare const RequireApprovalNever$inboundSchema: z.ZodEnum<typeof RequireApprovalNever>;
+/** @internal */
+export declare const RequireApprovalNever$outboundSchema: z.ZodEnum<typeof RequireApprovalNever>;
+/** @internal */
+export declare const RequireApprovalAlways$inboundSchema: z.ZodEnum<typeof RequireApprovalAlways>;
+/** @internal */
+export declare const RequireApprovalAlways$outboundSchema: z.ZodEnum<typeof RequireApprovalAlways>;
+/** @internal */
+export declare const Never$inboundSchema: z.ZodType<Never, unknown>;
+/** @internal */
+export type Never$Outbound = {
+    tool_names?: Array<string> | undefined;
+};
+/** @internal */
+export declare const Never$outboundSchema: z.ZodType<Never$Outbound, Never>;
+export declare function neverToJSON(never: Never): string;
+export declare function neverFromJSON(jsonString: string): SafeParseResult<Never, SDKValidationError>;
+/** @internal */
+export declare const Always$inboundSchema: z.ZodType<Always, unknown>;
+/** @internal */
+export type Always$Outbound = {
+    tool_names?: Array<string> | undefined;
+};
+/** @internal */
+export declare const Always$outboundSchema: z.ZodType<Always$Outbound, Always>;
+export declare function alwaysToJSON(always: Always): string;
+export declare function alwaysFromJSON(jsonString: string): SafeParseResult<Always, SDKValidationError>;
+/** @internal */
+export declare const RequireApproval$inboundSchema: z.ZodType<RequireApproval, unknown>;
+/** @internal */
+export type RequireApproval$Outbound = {
+    never?: Never$Outbound | undefined;
+    always?: Always$Outbound | undefined;
+};
+/** @internal */
+export declare const RequireApproval$outboundSchema: z.ZodType<RequireApproval$Outbound, RequireApproval>;
+export declare function requireApprovalToJSON(requireApproval: RequireApproval): string;
+export declare function requireApprovalFromJSON(jsonString: string): SafeParseResult<RequireApproval, SDKValidationError>;
+/** @internal */
+export declare const OpenResponsesMcpTool$inboundSchema: z.ZodType<OpenResponsesMcpTool, unknown>;
+/** @internal */
+export type OpenResponsesMcpTool$Outbound = {
+    type: "mcp";
+    server_label: string;
+    allowed_tools?: any | null | undefined;
+    authorization?: string | undefined;
+    connector_id?: string | undefined;
+    headers?: {
+        [k: string]: string;
+    } | null | undefined;
+    require_approval?: any | null | undefined;
+    server_description?: string | undefined;
+    server_url?: string | undefined;
+};
+/** @internal */
+export declare const OpenResponsesMcpTool$outboundSchema: z.ZodType<OpenResponsesMcpTool$Outbound, OpenResponsesMcpTool>;
+export declare function openResponsesMcpToolToJSON(openResponsesMcpTool: OpenResponsesMcpTool): string;
+export declare function openResponsesMcpToolFromJSON(jsonString: string): SafeParseResult<OpenResponsesMcpTool, SDKValidationError>;
+//# sourceMappingURL=openresponsesmcptool.d.ts.map