@openrouter/sdk 0.0.0-beta.40 → 0.0.0-beta.42

package/src/models/openresponsesnonstreamingresponse.ts

@@ -14,41 +14,70 @@ import {
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import {
-  OpenResponsesInput,
-  OpenResponsesInput$inboundSchema,
-  OpenResponsesInput$Outbound,
-  OpenResponsesInput$outboundSchema,
-} from "./openresponsesinput.js";
+  OpenAIResponsesPrompt,
+  OpenAIResponsesPrompt$inboundSchema,
+  OpenAIResponsesPrompt$Outbound,
+  OpenAIResponsesPrompt$outboundSchema,
+} from "./openairesponsesprompt.js";
 import {
-  OpenResponsesPrompt,
-  OpenResponsesPrompt$inboundSchema,
-  OpenResponsesPrompt$Outbound,
-  OpenResponsesPrompt$outboundSchema,
-} from "./openresponsesprompt.js";
+  OpenResponsesWebSearch20250826Tool,
+  OpenResponsesWebSearch20250826Tool$inboundSchema,
+  OpenResponsesWebSearch20250826Tool$Outbound,
+  OpenResponsesWebSearch20250826Tool$outboundSchema,
+} from "./openresponseswebsearch20250826tool.js";
 import {
-  OpenResponsesReasoningConfig,
-  OpenResponsesReasoningConfig$inboundSchema,
-  OpenResponsesReasoningConfig$Outbound,
-  OpenResponsesReasoningConfig$outboundSchema,
-} from "./openresponsesreasoningconfig.js";
+  OpenResponsesWebSearchPreview20250311Tool,
+  OpenResponsesWebSearchPreview20250311Tool$inboundSchema,
+  OpenResponsesWebSearchPreview20250311Tool$Outbound,
+  OpenResponsesWebSearchPreview20250311Tool$outboundSchema,
+} from "./openresponseswebsearchpreview20250311tool.js";
 import {
-  OpenResponsesTextConfig,
-  OpenResponsesTextConfig$inboundSchema,
-  OpenResponsesTextConfig$Outbound,
-  OpenResponsesTextConfig$outboundSchema,
-} from "./openresponsestextconfig.js";
+  OpenResponsesWebSearchPreviewTool,
+  OpenResponsesWebSearchPreviewTool$inboundSchema,
+  OpenResponsesWebSearchPreviewTool$Outbound,
+  OpenResponsesWebSearchPreviewTool$outboundSchema,
+} from "./openresponseswebsearchpreviewtool.js";
 import {
-  OpenResponsesToolChoice,
-  OpenResponsesToolChoice$inboundSchema,
-  OpenResponsesToolChoice$Outbound,
-  OpenResponsesToolChoice$outboundSchema,
-} from "./openresponsestoolchoice.js";
+  OpenResponsesWebSearchTool,
+  OpenResponsesWebSearchTool$inboundSchema,
+  OpenResponsesWebSearchTool$Outbound,
+  OpenResponsesWebSearchTool$outboundSchema,
+} from "./openresponseswebsearchtool.js";
 import {
-  OpenResponsesToolUnion,
-  OpenResponsesToolUnion$inboundSchema,
-  OpenResponsesToolUnion$Outbound,
-  OpenResponsesToolUnion$outboundSchema,
-} from "./openresponsestoolunion.js";
+  OutputItemImageGenerationCall,
+  OutputItemImageGenerationCall$inboundSchema,
+  OutputItemImageGenerationCall$Outbound,
+  OutputItemImageGenerationCall$outboundSchema,
+} from "./outputitemimagegenerationcall.js";
+import {
+  OutputMessage,
+  OutputMessage$inboundSchema,
+  OutputMessage$Outbound,
+  OutputMessage$outboundSchema,
+} from "./outputmessage.js";
+import {
+  ReasoningSummaryVerbosity,
+  ReasoningSummaryVerbosity$inboundSchema,
+  ReasoningSummaryVerbosity$outboundSchema,
+} from "./reasoningsummaryverbosity.js";
+import {
+  ResponseInputFile,
+  ResponseInputFile$inboundSchema,
+  ResponseInputFile$Outbound,
+  ResponseInputFile$outboundSchema,
+} from "./responseinputfile.js";
+import {
+  ResponseInputImage,
+  ResponseInputImage$inboundSchema,
+  ResponseInputImage$Outbound,
+  ResponseInputImage$outboundSchema,
+} from "./responseinputimage.js";
+import {
+  ResponseInputText,
+  ResponseInputText$inboundSchema,
+  ResponseInputText$Outbound,
+  ResponseInputText$outboundSchema,
+} from "./responseinputtext.js";
 import {
   ResponsesErrorField,
   ResponsesErrorField$inboundSchema,
@@ -62,11 +91,16 @@ import {
   ResponsesOutputItem$outboundSchema,
 } from "./responsesoutputitem.js";
 import {
-  ResponsesUsage,
-  ResponsesUsage$inboundSchema,
-  ResponsesUsage$Outbound,
-  ResponsesUsage$outboundSchema,
-} from "./responsesusage.js";
+  ResponseTextConfig,
+  ResponseTextConfig$inboundSchema,
+  ResponseTextConfig$Outbound,
+  ResponseTextConfig$outboundSchema,
+} from "./responsetextconfig.js";
+import {
+  ToolCallStatus,
+  ToolCallStatus$inboundSchema,
+  ToolCallStatus$outboundSchema,
+} from "./toolcallstatus.js";
 
 export const ObjectT = {
   Response: "response",
@@ -95,26 +129,323 @@ export type IncompleteDetails = {
   reason?: Reason | undefined;
 };
 
-export const ServiceTier = {
+export type InputTokensDetails = {
+  cachedTokens: number;
+};
+
+export type OutputTokensDetails = {
+  reasoningTokens: number;
+};
+
+export type Usage = {
+  inputTokens: number;
+  inputTokensDetails: InputTokensDetails;
+  outputTokens: number;
+  outputTokensDetails: OutputTokensDetails;
+  totalTokens: number;
+};
+
+export const InstructionsTypeFunctionCall = {
+  FunctionCall: "function_call",
+} as const;
+export type InstructionsTypeFunctionCall = ClosedEnum<
+  typeof InstructionsTypeFunctionCall
+>;
+
+export type InstructionsFunctionCall = {
+  type: InstructionsTypeFunctionCall;
+  callId: string;
+  name: string;
+  arguments: string;
+  id?: string | undefined;
+  status?: ToolCallStatus | undefined;
+};
+
+export const InstructionsTypeFunctionCallOutput = {
+  FunctionCallOutput: "function_call_output",
+} as const;
+export type InstructionsTypeFunctionCallOutput = ClosedEnum<
+  typeof InstructionsTypeFunctionCallOutput
+>;
+
+export type InstructionsFunctionCallOutput = {
+  type: InstructionsTypeFunctionCallOutput;
+  id: string;
+  callId: string;
+  output: string;
+  status?: ToolCallStatus | undefined;
+};
+
+export const InstructionsTypeMessage2 = {
+  Message: "message",
+} as const;
+export type InstructionsTypeMessage2 = ClosedEnum<
+  typeof InstructionsTypeMessage2
+>;
+
+export const OpenResponsesNonStreamingResponseRoleDeveloper2 = {
+  Developer: "developer",
+} as const;
+export type OpenResponsesNonStreamingResponseRoleDeveloper2 = ClosedEnum<
+  typeof OpenResponsesNonStreamingResponseRoleDeveloper2
+>;
+
+export const OpenResponsesNonStreamingResponseRoleSystem2 = {
+  System: "system",
+} as const;
+export type OpenResponsesNonStreamingResponseRoleSystem2 = ClosedEnum<
+  typeof OpenResponsesNonStreamingResponseRoleSystem2
+>;
+
+export const OpenResponsesNonStreamingResponseRoleUser2 = {
+  User: "user",
+} as const;
+export type OpenResponsesNonStreamingResponseRoleUser2 = ClosedEnum<
+  typeof OpenResponsesNonStreamingResponseRoleUser2
+>;
+
+export type OpenResponsesNonStreamingResponseRoleUnion2 =
+  | OpenResponsesNonStreamingResponseRoleUser2
+  | OpenResponsesNonStreamingResponseRoleSystem2
+  | OpenResponsesNonStreamingResponseRoleDeveloper2;
+
+export type OpenResponsesNonStreamingResponseContent3 =
+  | (ResponseInputText & { type: "input_text" })
+  | (ResponseInputImage & { type: "input_image" })
+  | (ResponseInputFile & { type: "input_file" });
+
+export type InstructionsMessage2 = {
+  id: string;
+  type?: InstructionsTypeMessage2 | undefined;
+  role:
+    | OpenResponsesNonStreamingResponseRoleUser2
+    | OpenResponsesNonStreamingResponseRoleSystem2
+    | OpenResponsesNonStreamingResponseRoleDeveloper2;
+  content: Array<
+    | (ResponseInputText & { type: "input_text" })
+    | (ResponseInputImage & { type: "input_image" })
+    | (ResponseInputFile & { type: "input_file" })
+  >;
+};
+
+export const InstructionsTypeMessage1 = {
+  Message: "message",
+} as const;
+export type InstructionsTypeMessage1 = ClosedEnum<
+  typeof InstructionsTypeMessage1
+>;
+
+export const OpenResponsesNonStreamingResponseRoleDeveloper1 = {
+  Developer: "developer",
+} as const;
+export type OpenResponsesNonStreamingResponseRoleDeveloper1 = ClosedEnum<
+  typeof OpenResponsesNonStreamingResponseRoleDeveloper1
+>;
+
+export const OpenResponsesNonStreamingResponseRoleAssistant = {
+  Assistant: "assistant",
+} as const;
+export type OpenResponsesNonStreamingResponseRoleAssistant = ClosedEnum<
+  typeof OpenResponsesNonStreamingResponseRoleAssistant
+>;
+
+export const OpenResponsesNonStreamingResponseRoleSystem1 = {
+  System: "system",
+} as const;
+export type OpenResponsesNonStreamingResponseRoleSystem1 = ClosedEnum<
+  typeof OpenResponsesNonStreamingResponseRoleSystem1
+>;
+
+export const OpenResponsesNonStreamingResponseRoleUser1 = {
+  User: "user",
+} as const;
+export type OpenResponsesNonStreamingResponseRoleUser1 = ClosedEnum<
+  typeof OpenResponsesNonStreamingResponseRoleUser1
+>;
+
+export type OpenResponsesNonStreamingResponseRoleUnion1 =
+  | OpenResponsesNonStreamingResponseRoleUser1
+  | OpenResponsesNonStreamingResponseRoleSystem1
+  | OpenResponsesNonStreamingResponseRoleAssistant
+  | OpenResponsesNonStreamingResponseRoleDeveloper1;
+
+export type OpenResponsesNonStreamingResponseContent1 =
+  | (ResponseInputText & { type: "input_text" })
+  | (ResponseInputImage & { type: "input_image" })
+  | (ResponseInputFile & { type: "input_file" });
+
+export type OpenResponsesNonStreamingResponseContent2 =
+  | Array<
+    | (ResponseInputText & { type: "input_text" })
+    | (ResponseInputImage & { type: "input_image" })
+    | (ResponseInputFile & { type: "input_file" })
+  >
+  | string;
+
+export type InstructionsMessage1 = {
+  type?: InstructionsTypeMessage1 | undefined;
+  role:
+    | OpenResponsesNonStreamingResponseRoleUser1
+    | OpenResponsesNonStreamingResponseRoleSystem1
+    | OpenResponsesNonStreamingResponseRoleAssistant
+    | OpenResponsesNonStreamingResponseRoleDeveloper1;
+  content:
+    | Array<
+      | (ResponseInputText & { type: "input_text" })
+      | (ResponseInputImage & { type: "input_image" })
+      | (ResponseInputFile & { type: "input_file" })
+    >
+    | string;
+};
+
+export type InstructionsUnion1 =
+  | InstructionsFunctionCallOutput
+  | InstructionsFunctionCall
+  | OutputItemImageGenerationCall
+  | OutputMessage
+  | InstructionsMessage2
+  | InstructionsMessage1;
+
+export type InstructionsUnion2 =
+  | string
+  | Array<
+    | InstructionsFunctionCallOutput
+    | InstructionsFunctionCall
+    | OutputItemImageGenerationCall
+    | OutputMessage
+    | InstructionsMessage2
+    | InstructionsMessage1
+  >
+  | any;
+
+export const OpenResponsesNonStreamingResponseToolType = {
+  Function: "function",
+} as const;
+export type OpenResponsesNonStreamingResponseToolType = ClosedEnum<
+  typeof OpenResponsesNonStreamingResponseToolType
+>;
+
+/**
+ * Function tool definition
+ */
+export type OpenResponsesNonStreamingResponseToolFunction = {
+  type: OpenResponsesNonStreamingResponseToolType;
+  name: string;
+  description?: string | null | undefined;
+  strict?: boolean | null | undefined;
+  parameters: { [k: string]: any | null } | null;
+};
+
+export type OpenResponsesNonStreamingResponseToolUnion =
+  | OpenResponsesNonStreamingResponseToolFunction
+  | OpenResponsesWebSearchPreviewTool
+  | OpenResponsesWebSearchPreview20250311Tool
+  | OpenResponsesWebSearchTool
+  | OpenResponsesWebSearch20250826Tool;
+
+export const OpenResponsesNonStreamingResponseTypeWebSearchPreview = {
+  WebSearchPreview: "web_search_preview",
+} as const;
+export type OpenResponsesNonStreamingResponseTypeWebSearchPreview = ClosedEnum<
+  typeof OpenResponsesNonStreamingResponseTypeWebSearchPreview
+>;
+
+export const OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311 = {
+  WebSearchPreview20250311: "web_search_preview_2025_03_11",
+} as const;
+export type OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311 =
+  ClosedEnum<
+    typeof OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311
+  >;
+
+export type OpenResponsesNonStreamingResponseTypeUnion =
+  | OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311
+  | OpenResponsesNonStreamingResponseTypeWebSearchPreview;
+
+export type OpenResponsesNonStreamingResponseToolChoice = {
+  type:
+    | OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311
+    | OpenResponsesNonStreamingResponseTypeWebSearchPreview;
+};
+
+export const OpenResponsesNonStreamingResponseToolChoiceTypeFunction = {
+  Function: "function",
+} as const;
+export type OpenResponsesNonStreamingResponseToolChoiceTypeFunction =
+  ClosedEnum<typeof OpenResponsesNonStreamingResponseToolChoiceTypeFunction>;
+
+export type OpenResponsesNonStreamingResponseToolChoiceFunction = {
+  type: OpenResponsesNonStreamingResponseToolChoiceTypeFunction;
+  name: string;
+};
+
+export const OpenResponsesNonStreamingResponseToolChoiceRequired = {
+  Required: "required",
+} as const;
+export type OpenResponsesNonStreamingResponseToolChoiceRequired = ClosedEnum<
+  typeof OpenResponsesNonStreamingResponseToolChoiceRequired
+>;
+
+export const OpenResponsesNonStreamingResponseToolChoiceNone = {
+  None: "none",
+} as const;
+export type OpenResponsesNonStreamingResponseToolChoiceNone = ClosedEnum<
+  typeof OpenResponsesNonStreamingResponseToolChoiceNone
+>;
+
+export const OpenResponsesNonStreamingResponseToolChoiceAuto = {
+  Auto: "auto",
+} as const;
+export type OpenResponsesNonStreamingResponseToolChoiceAuto = ClosedEnum<
+  typeof OpenResponsesNonStreamingResponseToolChoiceAuto
+>;
+
+export type OpenResponsesNonStreamingResponseToolChoiceUnion =
+  | OpenResponsesNonStreamingResponseToolChoiceFunction
+  | OpenResponsesNonStreamingResponseToolChoice
+  | OpenResponsesNonStreamingResponseToolChoiceAuto
+  | OpenResponsesNonStreamingResponseToolChoiceNone
+  | OpenResponsesNonStreamingResponseToolChoiceRequired;
+
+export const OpenResponsesNonStreamingResponseEffort = {
+  High: "high",
+  Medium: "medium",
+  Low: "low",
+  Minimal: "minimal",
+} as const;
+export type OpenResponsesNonStreamingResponseEffort = OpenEnum<
+  typeof OpenResponsesNonStreamingResponseEffort
+>;
+
+export type OpenResponsesNonStreamingResponseReasoning = {
+  effort?: OpenResponsesNonStreamingResponseEffort | null | undefined;
+  summary?: ReasoningSummaryVerbosity | undefined;
+};
+
+export const OpenResponsesNonStreamingResponseServiceTier = {
   Auto: "auto",
   Default: "default",
   Flex: "flex",
   Priority: "priority",
   Scale: "scale",
 } as const;
-export type ServiceTier = OpenEnum<typeof ServiceTier>;
+export type OpenResponsesNonStreamingResponseServiceTier = OpenEnum<
+  typeof OpenResponsesNonStreamingResponseServiceTier
+>;
 
-export const Truncation = {
+export const OpenResponsesNonStreamingResponseTruncation = {
   Auto: "auto",
   Disabled: "disabled",
 } as const;
-export type Truncation = OpenEnum<typeof Truncation>;
+export type OpenResponsesNonStreamingResponseTruncation = OpenEnum<
+  typeof OpenResponsesNonStreamingResponseTruncation
+>;
 
 /**
  * Complete non-streaming response from the Responses API
  */
 export type OpenResponsesNonStreamingResponse = {
-  id?: string | undefined;
+  id: string;
   object: ObjectT;
   createdAt: number;
   model: string;
@@ -129,46 +460,54 @@ export type OpenResponsesNonStreamingResponse = {
    */
   error: ResponsesErrorField | null;
   incompleteDetails: IncompleteDetails | null;
-  /**
-   * Token usage information for the response
-   */
-  usage?: ResponsesUsage | undefined;
+  usage?: Usage | undefined;
   maxToolCalls?: number | null | undefined;
   topLogprobs?: number | undefined;
   maxOutputTokens?: number | null | undefined;
   temperature: number | null;
   topP: number | null;
-  /**
-   * Input for a response request - can be a string or array of items
-   */
-  instructions?: OpenResponsesInput | null | undefined;
+  instructions?:
+    | string
+    | Array<
+      | InstructionsFunctionCallOutput
+      | InstructionsFunctionCall
+      | OutputItemImageGenerationCall
+      | OutputMessage
+      | InstructionsMessage2
+      | InstructionsMessage1
+    >
+    | any
+    | null
+    | undefined;
   /**
    * Metadata key-value pairs for the request. Keys must be ≤64 characters and cannot contain brackets. Values must be ≤512 characters. Maximum 16 pairs allowed.
    */
   metadata: { [k: string]: string } | null;
-  tools: Array<OpenResponsesToolUnion>;
-  /**
-   * Controls which tool the model should call
-   */
-  toolChoice: OpenResponsesToolChoice;
+  tools: Array<
+    | OpenResponsesNonStreamingResponseToolFunction
+    | OpenResponsesWebSearchPreviewTool
+    | OpenResponsesWebSearchPreview20250311Tool
+    | OpenResponsesWebSearchTool
+    | OpenResponsesWebSearch20250826Tool
+  >;
+  toolChoice:
+    | OpenResponsesNonStreamingResponseToolChoiceFunction
+    | OpenResponsesNonStreamingResponseToolChoice
+    | OpenResponsesNonStreamingResponseToolChoiceAuto
+    | OpenResponsesNonStreamingResponseToolChoiceNone
+    | OpenResponsesNonStreamingResponseToolChoiceRequired;
   parallelToolCalls: boolean;
-  /**
-   * Prompt template with variables for the response
-   */
-  prompt?: OpenResponsesPrompt | null | undefined;
+  prompt?: OpenAIResponsesPrompt | null | undefined;
   background?: boolean | null | undefined;
   previousResponseId?: string | null | undefined;
-  /**
-   * Configuration for reasoning mode in the response
-   */
-  reasoning?: OpenResponsesReasoningConfig | null | undefined;
-  serviceTier?: ServiceTier | null | undefined;
+  reasoning?: OpenResponsesNonStreamingResponseReasoning | null | undefined;
+  serviceTier?: OpenResponsesNonStreamingResponseServiceTier | null | undefined;
   store?: boolean | undefined;
-  truncation?: Truncation | null | undefined;
+  truncation?: OpenResponsesNonStreamingResponseTruncation | null | undefined;
   /**
    * Text output configuration including format and verbosity
    */
-  text?: OpenResponsesTextConfig | undefined;
+  text?: ResponseTextConfig | undefined;
 };
 
 /** @internal */
@@ -304,157 +643,2369 @@ export function incompleteDetailsFromJSON(
 }
 
 /** @internal */
-export const ServiceTier$inboundSchema: z.ZodType<
-  ServiceTier,
+export const InputTokensDetails$inboundSchema: z.ZodType<
+  InputTokensDetails,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ServiceTier),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = z.object({
+  cached_tokens: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    "cached_tokens": "cachedTokens",
+  });
+});
+
+/** @internal */
+export type InputTokensDetails$Outbound = {
+  cached_tokens: number;
+};
 
 /** @internal */
-export const ServiceTier$outboundSchema: z.ZodType<
-  ServiceTier,
+export const InputTokensDetails$outboundSchema: z.ZodType<
+  InputTokensDetails$Outbound,
   z.ZodTypeDef,
-  ServiceTier
-> = z.union([
-  z.nativeEnum(ServiceTier),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+  InputTokensDetails
+> = z.object({
+  cachedTokens: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    cachedTokens: "cached_tokens",
+  });
+});
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace ServiceTier$ {
-  /** @deprecated use `ServiceTier$inboundSchema` instead. */
-  export const inboundSchema = ServiceTier$inboundSchema;
-  /** @deprecated use `ServiceTier$outboundSchema` instead. */
-  export const outboundSchema = ServiceTier$outboundSchema;
+export namespace InputTokensDetails$ {
+  /** @deprecated use `InputTokensDetails$inboundSchema` instead. */
+  export const inboundSchema = InputTokensDetails$inboundSchema;
+  /** @deprecated use `InputTokensDetails$outboundSchema` instead. */
+  export const outboundSchema = InputTokensDetails$outboundSchema;
+  /** @deprecated use `InputTokensDetails$Outbound` instead. */
+  export type Outbound = InputTokensDetails$Outbound;
+}
+
+export function inputTokensDetailsToJSON(
+  inputTokensDetails: InputTokensDetails,
+): string {
+  return JSON.stringify(
+    InputTokensDetails$outboundSchema.parse(inputTokensDetails),
+  );
+}
+
+export function inputTokensDetailsFromJSON(
+  jsonString: string,
+): SafeParseResult<InputTokensDetails, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => InputTokensDetails$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'InputTokensDetails' from JSON`,
+  );
 }
 
 /** @internal */
-export const Truncation$inboundSchema: z.ZodType<
-  Truncation,
+export const OutputTokensDetails$inboundSchema: z.ZodType<
+  OutputTokensDetails,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(Truncation),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = z.object({
+  reasoning_tokens: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    "reasoning_tokens": "reasoningTokens",
+  });
+});
+
+/** @internal */
+export type OutputTokensDetails$Outbound = {
+  reasoning_tokens: number;
+};
 
 /** @internal */
-export const Truncation$outboundSchema: z.ZodType<
-  Truncation,
+export const OutputTokensDetails$outboundSchema: z.ZodType<
+  OutputTokensDetails$Outbound,
   z.ZodTypeDef,
-  Truncation
-> = z.union([
-  z.nativeEnum(Truncation),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+  OutputTokensDetails
+> = z.object({
+  reasoningTokens: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    reasoningTokens: "reasoning_tokens",
+  });
+});
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace Truncation$ {
-  /** @deprecated use `Truncation$inboundSchema` instead. */
-  export const inboundSchema = Truncation$inboundSchema;
-  /** @deprecated use `Truncation$outboundSchema` instead. */
-  export const outboundSchema = Truncation$outboundSchema;
+export namespace OutputTokensDetails$ {
+  /** @deprecated use `OutputTokensDetails$inboundSchema` instead. */
+  export const inboundSchema = OutputTokensDetails$inboundSchema;
+  /** @deprecated use `OutputTokensDetails$outboundSchema` instead. */
+  export const outboundSchema = OutputTokensDetails$outboundSchema;
+  /** @deprecated use `OutputTokensDetails$Outbound` instead. */
+  export type Outbound = OutputTokensDetails$Outbound;
+}
+
+export function outputTokensDetailsToJSON(
+  outputTokensDetails: OutputTokensDetails,
+): string {
+  return JSON.stringify(
+    OutputTokensDetails$outboundSchema.parse(outputTokensDetails),
+  );
+}
+
+export function outputTokensDetailsFromJSON(
+  jsonString: string,
+): SafeParseResult<OutputTokensDetails, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OutputTokensDetails$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OutputTokensDetails' from JSON`,
+  );
 }
 
 /** @internal */
-export const OpenResponsesNonStreamingResponse$inboundSchema: z.ZodType<
-  OpenResponsesNonStreamingResponse,
+export const Usage$inboundSchema: z.ZodType<Usage, z.ZodTypeDef, unknown> = z
+  .object({
+    input_tokens: z.number(),
+    input_tokens_details: z.lazy(() => InputTokensDetails$inboundSchema),
+    output_tokens: z.number(),
+    output_tokens_details: z.lazy(() => OutputTokensDetails$inboundSchema),
+    total_tokens: z.number(),
+  }).transform((v) => {
+    return remap$(v, {
+      "input_tokens": "inputTokens",
+      "input_tokens_details": "inputTokensDetails",
+      "output_tokens": "outputTokens",
+      "output_tokens_details": "outputTokensDetails",
+      "total_tokens": "totalTokens",
+    });
+  });
+
+/** @internal */
+export type Usage$Outbound = {
+  input_tokens: number;
+  input_tokens_details: InputTokensDetails$Outbound;
+  output_tokens: number;
+  output_tokens_details: OutputTokensDetails$Outbound;
+  total_tokens: number;
+};
+
+/** @internal */
+export const Usage$outboundSchema: z.ZodType<
+  Usage$Outbound,
+  z.ZodTypeDef,
+  Usage
+> = z.object({
+  inputTokens: z.number(),
+  inputTokensDetails: z.lazy(() => InputTokensDetails$outboundSchema),
+  outputTokens: z.number(),
+  outputTokensDetails: z.lazy(() => OutputTokensDetails$outboundSchema),
+  totalTokens: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    inputTokens: "input_tokens",
+    inputTokensDetails: "input_tokens_details",
+    outputTokens: "output_tokens",
+    outputTokensDetails: "output_tokens_details",
+    totalTokens: "total_tokens",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Usage$ {
+  /** @deprecated use `Usage$inboundSchema` instead. */
+  export const inboundSchema = Usage$inboundSchema;
+  /** @deprecated use `Usage$outboundSchema` instead. */
+  export const outboundSchema = Usage$outboundSchema;
+  /** @deprecated use `Usage$Outbound` instead. */
+  export type Outbound = Usage$Outbound;
+}
+
+export function usageToJSON(usage: Usage): string {
+  return JSON.stringify(Usage$outboundSchema.parse(usage));
+}
+
+export function usageFromJSON(
+  jsonString: string,
+): SafeParseResult<Usage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Usage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Usage' from JSON`,
+  );
+}
+
+/** @internal */
+export const InstructionsTypeFunctionCall$inboundSchema: z.ZodNativeEnum<
+  typeof InstructionsTypeFunctionCall
+> = z.nativeEnum(InstructionsTypeFunctionCall);
+
+/** @internal */
+export const InstructionsTypeFunctionCall$outboundSchema: z.ZodNativeEnum<
+  typeof InstructionsTypeFunctionCall
+> = InstructionsTypeFunctionCall$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace InstructionsTypeFunctionCall$ {
+  /** @deprecated use `InstructionsTypeFunctionCall$inboundSchema` instead. */
+  export const inboundSchema = InstructionsTypeFunctionCall$inboundSchema;
+  /** @deprecated use `InstructionsTypeFunctionCall$outboundSchema` instead. */
+  export const outboundSchema = InstructionsTypeFunctionCall$outboundSchema;
+}
+
+/** @internal */
+export const InstructionsFunctionCall$inboundSchema: z.ZodType<
+  InstructionsFunctionCall,
   z.ZodTypeDef,
   unknown
 > = z.object({
+  type: InstructionsTypeFunctionCall$inboundSchema,
+  call_id: z.string(),
+  name: z.string(),
+  arguments: z.string(),
   id: z.string().optional(),
-  object: ObjectT$inboundSchema,
-  created_at: z.number(),
-  model: z.string(),
-  status: OpenResponsesNonStreamingResponseStatus$inboundSchema.optional(),
-  output: z.array(ResponsesOutputItem$inboundSchema),
-  user: z.nullable(z.string()).optional(),
-  output_text: z.string().optional(),
-  prompt_cache_key: z.nullable(z.string()).optional(),
-  safety_identifier: z.nullable(z.string()).optional(),
-  error: z.nullable(ResponsesErrorField$inboundSchema),
-  incomplete_details: z.nullable(z.lazy(() => IncompleteDetails$inboundSchema)),
-  usage: ResponsesUsage$inboundSchema.optional(),
-  max_tool_calls: z.nullable(z.number()).optional(),
-  top_logprobs: z.number().optional(),
-  max_output_tokens: z.nullable(z.number()).optional(),
-  temperature: z.nullable(z.number()),
-  top_p: z.nullable(z.number()),
-  instructions: z.nullable(OpenResponsesInput$inboundSchema).optional(),
-  metadata: z.nullable(z.record(z.string())),
-  tools: z.array(OpenResponsesToolUnion$inboundSchema),
-  tool_choice: OpenResponsesToolChoice$inboundSchema,
-  parallel_tool_calls: z.boolean(),
-  prompt: z.nullable(OpenResponsesPrompt$inboundSchema).optional(),
-  background: z.nullable(z.boolean()).optional(),
-  previous_response_id: z.nullable(z.string()).optional(),
-  reasoning: z.nullable(OpenResponsesReasoningConfig$inboundSchema).optional(),
-  service_tier: z.nullable(ServiceTier$inboundSchema).optional(),
-  store: z.boolean().optional(),
-  truncation: z.nullable(Truncation$inboundSchema).optional(),
-  text: OpenResponsesTextConfig$inboundSchema.optional(),
+  status: ToolCallStatus$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
-    "created_at": "createdAt",
-    "output_text": "outputText",
-    "prompt_cache_key": "promptCacheKey",
-    "safety_identifier": "safetyIdentifier",
-    "incomplete_details": "incompleteDetails",
-    "max_tool_calls": "maxToolCalls",
-    "top_logprobs": "topLogprobs",
-    "max_output_tokens": "maxOutputTokens",
-    "top_p": "topP",
-    "tool_choice": "toolChoice",
-    "parallel_tool_calls": "parallelToolCalls",
-    "previous_response_id": "previousResponseId",
-    "service_tier": "serviceTier",
+    "call_id": "callId",
   });
 });
 
 /** @internal */
-export type OpenResponsesNonStreamingResponse$Outbound = {
+export type InstructionsFunctionCall$Outbound = {
+  type: string;
+  call_id: string;
+  name: string;
+  arguments: string;
   id?: string | undefined;
-  object: string;
-  created_at: number;
-  model: string;
   status?: string | undefined;
-  output: Array<ResponsesOutputItem$Outbound>;
-  user?: string | null | undefined;
-  output_text?: string | undefined;
-  prompt_cache_key?: string | null | undefined;
-  safety_identifier?: string | null | undefined;
-  error: ResponsesErrorField$Outbound | null;
+};
+
+/** @internal */
+export const InstructionsFunctionCall$outboundSchema: z.ZodType<
+  InstructionsFunctionCall$Outbound,
+  z.ZodTypeDef,
+  InstructionsFunctionCall
+> = z.object({
+  type: InstructionsTypeFunctionCall$outboundSchema,
+  callId: z.string(),
+  name: z.string(),
+  arguments: z.string(),
+  id: z.string().optional(),
+  status: ToolCallStatus$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    callId: "call_id",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace InstructionsFunctionCall$ {
+  /** @deprecated use `InstructionsFunctionCall$inboundSchema` instead. */
+  export const inboundSchema = InstructionsFunctionCall$inboundSchema;
+  /** @deprecated use `InstructionsFunctionCall$outboundSchema` instead. */
+  export const outboundSchema = InstructionsFunctionCall$outboundSchema;
+  /** @deprecated use `InstructionsFunctionCall$Outbound` instead. */
+  export type Outbound = InstructionsFunctionCall$Outbound;
+}
+
+export function instructionsFunctionCallToJSON(
+  instructionsFunctionCall: InstructionsFunctionCall,
+): string {
+  return JSON.stringify(
+    InstructionsFunctionCall$outboundSchema.parse(instructionsFunctionCall),
+  );
+}
+
+export function instructionsFunctionCallFromJSON(
+  jsonString: string,
+): SafeParseResult<InstructionsFunctionCall, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => InstructionsFunctionCall$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'InstructionsFunctionCall' from JSON`,
+  );
+}
+
+/** @internal */
+export const InstructionsTypeFunctionCallOutput$inboundSchema: z.ZodNativeEnum<
+  typeof InstructionsTypeFunctionCallOutput
+> = z.nativeEnum(InstructionsTypeFunctionCallOutput);
+
+/** @internal */
+export const InstructionsTypeFunctionCallOutput$outboundSchema: z.ZodNativeEnum<
+  typeof InstructionsTypeFunctionCallOutput
+> = InstructionsTypeFunctionCallOutput$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace InstructionsTypeFunctionCallOutput$ {
+  /** @deprecated use `InstructionsTypeFunctionCallOutput$inboundSchema` instead. */
+  export const inboundSchema = InstructionsTypeFunctionCallOutput$inboundSchema;
+  /** @deprecated use `InstructionsTypeFunctionCallOutput$outboundSchema` instead. */
+  export const outboundSchema =
+    InstructionsTypeFunctionCallOutput$outboundSchema;
+}
+
+/** @internal */
+export const InstructionsFunctionCallOutput$inboundSchema: z.ZodType<
+  InstructionsFunctionCallOutput,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: InstructionsTypeFunctionCallOutput$inboundSchema,
+  id: z.string(),
+  call_id: z.string(),
+  output: z.string(),
+  status: ToolCallStatus$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "call_id": "callId",
+  });
+});
+
+/** @internal */
+export type InstructionsFunctionCallOutput$Outbound = {
+  type: string;
+  id: string;
+  call_id: string;
+  output: string;
+  status?: string | undefined;
+};
+
+/** @internal */
+export const InstructionsFunctionCallOutput$outboundSchema: z.ZodType<
+  InstructionsFunctionCallOutput$Outbound,
+  z.ZodTypeDef,
+  InstructionsFunctionCallOutput
+> = z.object({
+  type: InstructionsTypeFunctionCallOutput$outboundSchema,
+  id: z.string(),
+  callId: z.string(),
+  output: z.string(),
+  status: ToolCallStatus$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    callId: "call_id",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace InstructionsFunctionCallOutput$ {
+  /** @deprecated use `InstructionsFunctionCallOutput$inboundSchema` instead. */
+  export const inboundSchema = InstructionsFunctionCallOutput$inboundSchema;
+  /** @deprecated use `InstructionsFunctionCallOutput$outboundSchema` instead. */
+  export const outboundSchema = InstructionsFunctionCallOutput$outboundSchema;
+  /** @deprecated use `InstructionsFunctionCallOutput$Outbound` instead. */
+  export type Outbound = InstructionsFunctionCallOutput$Outbound;
+}
+
+export function instructionsFunctionCallOutputToJSON(
+  instructionsFunctionCallOutput: InstructionsFunctionCallOutput,
+): string {
+  return JSON.stringify(
+    InstructionsFunctionCallOutput$outboundSchema.parse(
+      instructionsFunctionCallOutput,
+    ),
+  );
+}
+
+export function instructionsFunctionCallOutputFromJSON(
+  jsonString: string,
+): SafeParseResult<InstructionsFunctionCallOutput, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => InstructionsFunctionCallOutput$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'InstructionsFunctionCallOutput' from JSON`,
+  );
+}
+
+/** @internal */
+export const InstructionsTypeMessage2$inboundSchema: z.ZodNativeEnum<
+  typeof InstructionsTypeMessage2
+> = z.nativeEnum(InstructionsTypeMessage2);
+
+/** @internal */
+export const InstructionsTypeMessage2$outboundSchema: z.ZodNativeEnum<
+  typeof InstructionsTypeMessage2
+> = InstructionsTypeMessage2$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace InstructionsTypeMessage2$ {
+  /** @deprecated use `InstructionsTypeMessage2$inboundSchema` instead. */
+  export const inboundSchema = InstructionsTypeMessage2$inboundSchema;
+  /** @deprecated use `InstructionsTypeMessage2$outboundSchema` instead. */
+  export const outboundSchema = InstructionsTypeMessage2$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleDeveloper2$inboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseRoleDeveloper2> = z
+    .nativeEnum(OpenResponsesNonStreamingResponseRoleDeveloper2);
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleDeveloper2$outboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseRoleDeveloper2> =
+    OpenResponsesNonStreamingResponseRoleDeveloper2$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseRoleDeveloper2$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseRoleDeveloper2$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseRoleDeveloper2$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseRoleDeveloper2$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseRoleDeveloper2$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleSystem2$inboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseRoleSystem2> = z
+    .nativeEnum(OpenResponsesNonStreamingResponseRoleSystem2);
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleSystem2$outboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseRoleSystem2> =
+    OpenResponsesNonStreamingResponseRoleSystem2$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseRoleSystem2$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseRoleSystem2$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseRoleSystem2$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseRoleSystem2$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseRoleSystem2$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleUser2$inboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseRoleUser2> = z
+    .nativeEnum(OpenResponsesNonStreamingResponseRoleUser2);
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleUser2$outboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseRoleUser2> =
+    OpenResponsesNonStreamingResponseRoleUser2$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseRoleUser2$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseRoleUser2$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseRoleUser2$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseRoleUser2$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseRoleUser2$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleUnion2$inboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseRoleUnion2,
+    z.ZodTypeDef,
+    unknown
+  > = z.union([
+    OpenResponsesNonStreamingResponseRoleUser2$inboundSchema,
+    OpenResponsesNonStreamingResponseRoleSystem2$inboundSchema,
+    OpenResponsesNonStreamingResponseRoleDeveloper2$inboundSchema,
+  ]);
+
+/** @internal */
+export type OpenResponsesNonStreamingResponseRoleUnion2$Outbound =
+  | string
+  | string
+  | string;
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleUnion2$outboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseRoleUnion2$Outbound,
+    z.ZodTypeDef,
+    OpenResponsesNonStreamingResponseRoleUnion2
+  > = z.union([
+    OpenResponsesNonStreamingResponseRoleUser2$outboundSchema,
+    OpenResponsesNonStreamingResponseRoleSystem2$outboundSchema,
+    OpenResponsesNonStreamingResponseRoleDeveloper2$outboundSchema,
+  ]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseRoleUnion2$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseRoleUnion2$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseRoleUnion2$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseRoleUnion2$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseRoleUnion2$outboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseRoleUnion2$Outbound` instead. */
+  export type Outbound = OpenResponsesNonStreamingResponseRoleUnion2$Outbound;
+}
+
+export function openResponsesNonStreamingResponseRoleUnion2ToJSON(
+  openResponsesNonStreamingResponseRoleUnion2:
+    OpenResponsesNonStreamingResponseRoleUnion2,
+): string {
+  return JSON.stringify(
+    OpenResponsesNonStreamingResponseRoleUnion2$outboundSchema.parse(
+      openResponsesNonStreamingResponseRoleUnion2,
+    ),
+  );
+}
+
+export function openResponsesNonStreamingResponseRoleUnion2FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  OpenResponsesNonStreamingResponseRoleUnion2,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      OpenResponsesNonStreamingResponseRoleUnion2$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'OpenResponsesNonStreamingResponseRoleUnion2' from JSON`,
+  );
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseContent3$inboundSchema: z.ZodType<
+  OpenResponsesNonStreamingResponseContent3,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  ResponseInputText$inboundSchema.and(
+    z.object({ type: z.literal("input_text") }).transform((v) => ({
+      type: v.type,
+    })),
+  ),
+  ResponseInputImage$inboundSchema.and(
+    z.object({ type: z.literal("input_image") }).transform((v) => ({
+      type: v.type,
+    })),
+  ),
+  ResponseInputFile$inboundSchema.and(
+    z.object({ type: z.literal("input_file") }).transform((v) => ({
+      type: v.type,
+    })),
+  ),
+]);
+
+/** @internal */
+export type OpenResponsesNonStreamingResponseContent3$Outbound =
+  | (ResponseInputText$Outbound & { type: "input_text" })
+  | (ResponseInputImage$Outbound & { type: "input_image" })
+  | (ResponseInputFile$Outbound & { type: "input_file" });
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseContent3$outboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseContent3$Outbound,
+    z.ZodTypeDef,
+    OpenResponsesNonStreamingResponseContent3
+  > = z.union([
+    ResponseInputText$outboundSchema.and(
+      z.object({ type: z.literal("input_text") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+    ResponseInputImage$outboundSchema.and(
+      z.object({ type: z.literal("input_image") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+    ResponseInputFile$outboundSchema.and(
+      z.object({ type: z.literal("input_file") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+  ]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseContent3$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseContent3$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseContent3$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseContent3$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseContent3$outboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseContent3$Outbound` instead. */
+  export type Outbound = OpenResponsesNonStreamingResponseContent3$Outbound;
+}
+
+export function openResponsesNonStreamingResponseContent3ToJSON(
+  openResponsesNonStreamingResponseContent3:
+    OpenResponsesNonStreamingResponseContent3,
+): string {
+  return JSON.stringify(
+    OpenResponsesNonStreamingResponseContent3$outboundSchema.parse(
+      openResponsesNonStreamingResponseContent3,
+    ),
+  );
+}
+
+export function openResponsesNonStreamingResponseContent3FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  OpenResponsesNonStreamingResponseContent3,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      OpenResponsesNonStreamingResponseContent3$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'OpenResponsesNonStreamingResponseContent3' from JSON`,
+  );
+}
+
+/** @internal */
+export const InstructionsMessage2$inboundSchema: z.ZodType<
+  InstructionsMessage2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  type: InstructionsTypeMessage2$inboundSchema.optional(),
+  role: z.union([
+    OpenResponsesNonStreamingResponseRoleUser2$inboundSchema,
+    OpenResponsesNonStreamingResponseRoleSystem2$inboundSchema,
+    OpenResponsesNonStreamingResponseRoleDeveloper2$inboundSchema,
+  ]),
+  content: z.array(
+    z.union([
+      ResponseInputText$inboundSchema.and(
+        z.object({ type: z.literal("input_text") }).transform((v) => ({
+          type: v.type,
+        })),
+      ),
+      ResponseInputImage$inboundSchema.and(
+        z.object({ type: z.literal("input_image") }).transform((v) => ({
+          type: v.type,
+        })),
+      ),
+      ResponseInputFile$inboundSchema.and(
+        z.object({ type: z.literal("input_file") }).transform((v) => ({
+          type: v.type,
+        })),
+      ),
+    ]),
+  ),
+});
+
+/** @internal */
+export type InstructionsMessage2$Outbound = {
+  id: string;
+  type?: string | undefined;
+  role: string | string | string;
+  content: Array<
+    | (ResponseInputText$Outbound & { type: "input_text" })
+    | (ResponseInputImage$Outbound & { type: "input_image" })
+    | (ResponseInputFile$Outbound & { type: "input_file" })
+  >;
+};
+
+/** @internal */
+export const InstructionsMessage2$outboundSchema: z.ZodType<
+  InstructionsMessage2$Outbound,
+  z.ZodTypeDef,
+  InstructionsMessage2
+> = z.object({
+  id: z.string(),
+  type: InstructionsTypeMessage2$outboundSchema.optional(),
+  role: z.union([
+    OpenResponsesNonStreamingResponseRoleUser2$outboundSchema,
+    OpenResponsesNonStreamingResponseRoleSystem2$outboundSchema,
+    OpenResponsesNonStreamingResponseRoleDeveloper2$outboundSchema,
+  ]),
+  content: z.array(
+    z.union([
+      ResponseInputText$outboundSchema.and(
+        z.object({ type: z.literal("input_text") }).transform((v) => ({
+          type: v.type,
+        })),
+      ),
+      ResponseInputImage$outboundSchema.and(
+        z.object({ type: z.literal("input_image") }).transform((v) => ({
+          type: v.type,
+        })),
+      ),
+      ResponseInputFile$outboundSchema.and(
+        z.object({ type: z.literal("input_file") }).transform((v) => ({
+          type: v.type,
+        })),
+      ),
+    ]),
+  ),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace InstructionsMessage2$ {
+  /** @deprecated use `InstructionsMessage2$inboundSchema` instead. */
+  export const inboundSchema = InstructionsMessage2$inboundSchema;
+  /** @deprecated use `InstructionsMessage2$outboundSchema` instead. */
+  export const outboundSchema = InstructionsMessage2$outboundSchema;
+  /** @deprecated use `InstructionsMessage2$Outbound` instead. */
+  export type Outbound = InstructionsMessage2$Outbound;
+}
+
+export function instructionsMessage2ToJSON(
+  instructionsMessage2: InstructionsMessage2,
+): string {
+  return JSON.stringify(
+    InstructionsMessage2$outboundSchema.parse(instructionsMessage2),
+  );
+}
+
+export function instructionsMessage2FromJSON(
+  jsonString: string,
+): SafeParseResult<InstructionsMessage2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => InstructionsMessage2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'InstructionsMessage2' from JSON`,
+  );
+}
+
+/** @internal */
+export const InstructionsTypeMessage1$inboundSchema: z.ZodNativeEnum<
+  typeof InstructionsTypeMessage1
+> = z.nativeEnum(InstructionsTypeMessage1);
+
+/** @internal */
+export const InstructionsTypeMessage1$outboundSchema: z.ZodNativeEnum<
+  typeof InstructionsTypeMessage1
+> = InstructionsTypeMessage1$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace InstructionsTypeMessage1$ {
+  /** @deprecated use `InstructionsTypeMessage1$inboundSchema` instead. */
+  export const inboundSchema = InstructionsTypeMessage1$inboundSchema;
+  /** @deprecated use `InstructionsTypeMessage1$outboundSchema` instead. */
+  export const outboundSchema = InstructionsTypeMessage1$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleDeveloper1$inboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseRoleDeveloper1> = z
+    .nativeEnum(OpenResponsesNonStreamingResponseRoleDeveloper1);
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleDeveloper1$outboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseRoleDeveloper1> =
+    OpenResponsesNonStreamingResponseRoleDeveloper1$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseRoleDeveloper1$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseRoleDeveloper1$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseRoleDeveloper1$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseRoleDeveloper1$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseRoleDeveloper1$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleAssistant$inboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseRoleAssistant> = z
+    .nativeEnum(OpenResponsesNonStreamingResponseRoleAssistant);
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleAssistant$outboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseRoleAssistant> =
+    OpenResponsesNonStreamingResponseRoleAssistant$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseRoleAssistant$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseRoleAssistant$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseRoleAssistant$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseRoleAssistant$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseRoleAssistant$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleSystem1$inboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseRoleSystem1> = z
+    .nativeEnum(OpenResponsesNonStreamingResponseRoleSystem1);
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleSystem1$outboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseRoleSystem1> =
+    OpenResponsesNonStreamingResponseRoleSystem1$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseRoleSystem1$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseRoleSystem1$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseRoleSystem1$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseRoleSystem1$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseRoleSystem1$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleUser1$inboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseRoleUser1> = z
+    .nativeEnum(OpenResponsesNonStreamingResponseRoleUser1);
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleUser1$outboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseRoleUser1> =
+    OpenResponsesNonStreamingResponseRoleUser1$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseRoleUser1$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseRoleUser1$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseRoleUser1$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseRoleUser1$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseRoleUser1$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleUnion1$inboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseRoleUnion1,
+    z.ZodTypeDef,
+    unknown
+  > = z.union([
+    OpenResponsesNonStreamingResponseRoleUser1$inboundSchema,
+    OpenResponsesNonStreamingResponseRoleSystem1$inboundSchema,
+    OpenResponsesNonStreamingResponseRoleAssistant$inboundSchema,
+    OpenResponsesNonStreamingResponseRoleDeveloper1$inboundSchema,
+  ]);
+
+/** @internal */
+export type OpenResponsesNonStreamingResponseRoleUnion1$Outbound =
+  | string
+  | string
+  | string
+  | string;
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleUnion1$outboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseRoleUnion1$Outbound,
+    z.ZodTypeDef,
+    OpenResponsesNonStreamingResponseRoleUnion1
+  > = z.union([
+    OpenResponsesNonStreamingResponseRoleUser1$outboundSchema,
+    OpenResponsesNonStreamingResponseRoleSystem1$outboundSchema,
+    OpenResponsesNonStreamingResponseRoleAssistant$outboundSchema,
+    OpenResponsesNonStreamingResponseRoleDeveloper1$outboundSchema,
+  ]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseRoleUnion1$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseRoleUnion1$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseRoleUnion1$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseRoleUnion1$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseRoleUnion1$outboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseRoleUnion1$Outbound` instead. */
+  export type Outbound = OpenResponsesNonStreamingResponseRoleUnion1$Outbound;
+}
+
+export function openResponsesNonStreamingResponseRoleUnion1ToJSON(
+  openResponsesNonStreamingResponseRoleUnion1:
+    OpenResponsesNonStreamingResponseRoleUnion1,
+): string {
+  return JSON.stringify(
+    OpenResponsesNonStreamingResponseRoleUnion1$outboundSchema.parse(
+      openResponsesNonStreamingResponseRoleUnion1,
+    ),
+  );
+}
+
+export function openResponsesNonStreamingResponseRoleUnion1FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  OpenResponsesNonStreamingResponseRoleUnion1,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      OpenResponsesNonStreamingResponseRoleUnion1$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'OpenResponsesNonStreamingResponseRoleUnion1' from JSON`,
+  );
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseContent1$inboundSchema: z.ZodType<
+  OpenResponsesNonStreamingResponseContent1,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  ResponseInputText$inboundSchema.and(
+    z.object({ type: z.literal("input_text") }).transform((v) => ({
+      type: v.type,
+    })),
+  ),
+  ResponseInputImage$inboundSchema.and(
+    z.object({ type: z.literal("input_image") }).transform((v) => ({
+      type: v.type,
+    })),
+  ),
+  ResponseInputFile$inboundSchema.and(
+    z.object({ type: z.literal("input_file") }).transform((v) => ({
+      type: v.type,
+    })),
+  ),
+]);
+
+/** @internal */
+export type OpenResponsesNonStreamingResponseContent1$Outbound =
+  | (ResponseInputText$Outbound & { type: "input_text" })
+  | (ResponseInputImage$Outbound & { type: "input_image" })
+  | (ResponseInputFile$Outbound & { type: "input_file" });
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseContent1$outboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseContent1$Outbound,
+    z.ZodTypeDef,
+    OpenResponsesNonStreamingResponseContent1
+  > = z.union([
+    ResponseInputText$outboundSchema.and(
+      z.object({ type: z.literal("input_text") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+    ResponseInputImage$outboundSchema.and(
+      z.object({ type: z.literal("input_image") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+    ResponseInputFile$outboundSchema.and(
+      z.object({ type: z.literal("input_file") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+  ]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseContent1$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseContent1$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseContent1$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseContent1$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseContent1$outboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseContent1$Outbound` instead. */
+  export type Outbound = OpenResponsesNonStreamingResponseContent1$Outbound;
+}
+
+export function openResponsesNonStreamingResponseContent1ToJSON(
+  openResponsesNonStreamingResponseContent1:
+    OpenResponsesNonStreamingResponseContent1,
+): string {
+  return JSON.stringify(
+    OpenResponsesNonStreamingResponseContent1$outboundSchema.parse(
+      openResponsesNonStreamingResponseContent1,
+    ),
+  );
+}
+
+export function openResponsesNonStreamingResponseContent1FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  OpenResponsesNonStreamingResponseContent1,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      OpenResponsesNonStreamingResponseContent1$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'OpenResponsesNonStreamingResponseContent1' from JSON`,
+  );
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseContent2$inboundSchema: z.ZodType<
+  OpenResponsesNonStreamingResponseContent2,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.array(
+    z.union([
+      ResponseInputText$inboundSchema.and(
+        z.object({ type: z.literal("input_text") }).transform((v) => ({
+          type: v.type,
+        })),
+      ),
+      ResponseInputImage$inboundSchema.and(
+        z.object({ type: z.literal("input_image") }).transform((v) => ({
+          type: v.type,
+        })),
+      ),
+      ResponseInputFile$inboundSchema.and(
+        z.object({ type: z.literal("input_file") }).transform((v) => ({
+          type: v.type,
+        })),
+      ),
+    ]),
+  ),
+  z.string(),
+]);
+
+/** @internal */
+export type OpenResponsesNonStreamingResponseContent2$Outbound =
+  | Array<
+    | (ResponseInputText$Outbound & { type: "input_text" })
+    | (ResponseInputImage$Outbound & { type: "input_image" })
+    | (ResponseInputFile$Outbound & { type: "input_file" })
+  >
+  | string;
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseContent2$outboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseContent2$Outbound,
+    z.ZodTypeDef,
+    OpenResponsesNonStreamingResponseContent2
+  > = z.union([
+    z.array(
+      z.union([
+        ResponseInputText$outboundSchema.and(
+          z.object({ type: z.literal("input_text") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        ResponseInputImage$outboundSchema.and(
+          z.object({ type: z.literal("input_image") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        ResponseInputFile$outboundSchema.and(
+          z.object({ type: z.literal("input_file") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+      ]),
+    ),
+    z.string(),
+  ]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseContent2$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseContent2$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseContent2$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseContent2$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseContent2$outboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseContent2$Outbound` instead. */
+  export type Outbound = OpenResponsesNonStreamingResponseContent2$Outbound;
+}
+
+export function openResponsesNonStreamingResponseContent2ToJSON(
+  openResponsesNonStreamingResponseContent2:
+    OpenResponsesNonStreamingResponseContent2,
+): string {
+  return JSON.stringify(
+    OpenResponsesNonStreamingResponseContent2$outboundSchema.parse(
+      openResponsesNonStreamingResponseContent2,
+    ),
+  );
+}
+
+export function openResponsesNonStreamingResponseContent2FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  OpenResponsesNonStreamingResponseContent2,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      OpenResponsesNonStreamingResponseContent2$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'OpenResponsesNonStreamingResponseContent2' from JSON`,
+  );
+}
+
+/** @internal */
+export const InstructionsMessage1$inboundSchema: z.ZodType<
+  InstructionsMessage1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: InstructionsTypeMessage1$inboundSchema.optional(),
+  role: z.union([
+    OpenResponsesNonStreamingResponseRoleUser1$inboundSchema,
+    OpenResponsesNonStreamingResponseRoleSystem1$inboundSchema,
+    OpenResponsesNonStreamingResponseRoleAssistant$inboundSchema,
+    OpenResponsesNonStreamingResponseRoleDeveloper1$inboundSchema,
+  ]),
+  content: z.union([
+    z.array(
+      z.union([
+        ResponseInputText$inboundSchema.and(
+          z.object({ type: z.literal("input_text") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        ResponseInputImage$inboundSchema.and(
+          z.object({ type: z.literal("input_image") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        ResponseInputFile$inboundSchema.and(
+          z.object({ type: z.literal("input_file") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+      ]),
+    ),
+    z.string(),
+  ]),
+});
+
+/** @internal */
+export type InstructionsMessage1$Outbound = {
+  type?: string | undefined;
+  role: string | string | string | string;
+  content:
+    | Array<
+      | (ResponseInputText$Outbound & { type: "input_text" })
+      | (ResponseInputImage$Outbound & { type: "input_image" })
+      | (ResponseInputFile$Outbound & { type: "input_file" })
+    >
+    | string;
+};
+
+/** @internal */
+export const InstructionsMessage1$outboundSchema: z.ZodType<
+  InstructionsMessage1$Outbound,
+  z.ZodTypeDef,
+  InstructionsMessage1
+> = z.object({
+  type: InstructionsTypeMessage1$outboundSchema.optional(),
+  role: z.union([
+    OpenResponsesNonStreamingResponseRoleUser1$outboundSchema,
+    OpenResponsesNonStreamingResponseRoleSystem1$outboundSchema,
+    OpenResponsesNonStreamingResponseRoleAssistant$outboundSchema,
+    OpenResponsesNonStreamingResponseRoleDeveloper1$outboundSchema,
+  ]),
+  content: z.union([
+    z.array(
+      z.union([
+        ResponseInputText$outboundSchema.and(
+          z.object({ type: z.literal("input_text") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        ResponseInputImage$outboundSchema.and(
+          z.object({ type: z.literal("input_image") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        ResponseInputFile$outboundSchema.and(
+          z.object({ type: z.literal("input_file") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+      ]),
+    ),
+    z.string(),
+  ]),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace InstructionsMessage1$ {
+  /** @deprecated use `InstructionsMessage1$inboundSchema` instead. */
+  export const inboundSchema = InstructionsMessage1$inboundSchema;
+  /** @deprecated use `InstructionsMessage1$outboundSchema` instead. */
+  export const outboundSchema = InstructionsMessage1$outboundSchema;
+  /** @deprecated use `InstructionsMessage1$Outbound` instead. */
+  export type Outbound = InstructionsMessage1$Outbound;
+}
+
+export function instructionsMessage1ToJSON(
+  instructionsMessage1: InstructionsMessage1,
+): string {
+  return JSON.stringify(
+    InstructionsMessage1$outboundSchema.parse(instructionsMessage1),
+  );
+}
+
+export function instructionsMessage1FromJSON(
+  jsonString: string,
+): SafeParseResult<InstructionsMessage1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => InstructionsMessage1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'InstructionsMessage1' from JSON`,
+  );
+}
+
+/** @internal */
+export const InstructionsUnion1$inboundSchema: z.ZodType<
+  InstructionsUnion1,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => InstructionsFunctionCallOutput$inboundSchema),
+  z.lazy(() => InstructionsFunctionCall$inboundSchema),
+  OutputItemImageGenerationCall$inboundSchema,
+  OutputMessage$inboundSchema,
+  z.lazy(() => InstructionsMessage2$inboundSchema),
+  z.lazy(() => InstructionsMessage1$inboundSchema),
+]);
+
+/** @internal */
+export type InstructionsUnion1$Outbound =
+  | InstructionsFunctionCallOutput$Outbound
+  | InstructionsFunctionCall$Outbound
+  | OutputItemImageGenerationCall$Outbound
+  | OutputMessage$Outbound
+  | InstructionsMessage2$Outbound
+  | InstructionsMessage1$Outbound;
+
+/** @internal */
+export const InstructionsUnion1$outboundSchema: z.ZodType<
+  InstructionsUnion1$Outbound,
+  z.ZodTypeDef,
+  InstructionsUnion1
+> = z.union([
+  z.lazy(() => InstructionsFunctionCallOutput$outboundSchema),
+  z.lazy(() => InstructionsFunctionCall$outboundSchema),
+  OutputItemImageGenerationCall$outboundSchema,
+  OutputMessage$outboundSchema,
+  z.lazy(() => InstructionsMessage2$outboundSchema),
+  z.lazy(() => InstructionsMessage1$outboundSchema),
+]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace InstructionsUnion1$ {
+  /** @deprecated use `InstructionsUnion1$inboundSchema` instead. */
+  export const inboundSchema = InstructionsUnion1$inboundSchema;
+  /** @deprecated use `InstructionsUnion1$outboundSchema` instead. */
+  export const outboundSchema = InstructionsUnion1$outboundSchema;
+  /** @deprecated use `InstructionsUnion1$Outbound` instead. */
+  export type Outbound = InstructionsUnion1$Outbound;
+}
+
+export function instructionsUnion1ToJSON(
+  instructionsUnion1: InstructionsUnion1,
+): string {
+  return JSON.stringify(
+    InstructionsUnion1$outboundSchema.parse(instructionsUnion1),
+  );
+}
+
+export function instructionsUnion1FromJSON(
+  jsonString: string,
+): SafeParseResult<InstructionsUnion1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => InstructionsUnion1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'InstructionsUnion1' from JSON`,
+  );
+}
+
+/** @internal */
+export const InstructionsUnion2$inboundSchema: z.ZodType<
+  InstructionsUnion2,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.string(),
+  z.array(z.union([
+    z.lazy(() => InstructionsFunctionCallOutput$inboundSchema),
+    z.lazy(() => InstructionsFunctionCall$inboundSchema),
+    OutputItemImageGenerationCall$inboundSchema,
+    OutputMessage$inboundSchema,
+    z.lazy(() => InstructionsMessage2$inboundSchema),
+    z.lazy(() => InstructionsMessage1$inboundSchema),
+  ])),
+  z.any(),
+]);
+
+/** @internal */
+export type InstructionsUnion2$Outbound =
+  | string
+  | Array<
+    | InstructionsFunctionCallOutput$Outbound
+    | InstructionsFunctionCall$Outbound
+    | OutputItemImageGenerationCall$Outbound
+    | OutputMessage$Outbound
+    | InstructionsMessage2$Outbound
+    | InstructionsMessage1$Outbound
+  >
+  | any;
+
+/** @internal */
+export const InstructionsUnion2$outboundSchema: z.ZodType<
+  InstructionsUnion2$Outbound,
+  z.ZodTypeDef,
+  InstructionsUnion2
+> = z.union([
+  z.string(),
+  z.array(z.union([
+    z.lazy(() => InstructionsFunctionCallOutput$outboundSchema),
+    z.lazy(() => InstructionsFunctionCall$outboundSchema),
+    OutputItemImageGenerationCall$outboundSchema,
+    OutputMessage$outboundSchema,
+    z.lazy(() => InstructionsMessage2$outboundSchema),
+    z.lazy(() => InstructionsMessage1$outboundSchema),
+  ])),
+  z.any(),
+]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace InstructionsUnion2$ {
+  /** @deprecated use `InstructionsUnion2$inboundSchema` instead. */
+  export const inboundSchema = InstructionsUnion2$inboundSchema;
+  /** @deprecated use `InstructionsUnion2$outboundSchema` instead. */
+  export const outboundSchema = InstructionsUnion2$outboundSchema;
+  /** @deprecated use `InstructionsUnion2$Outbound` instead. */
+  export type Outbound = InstructionsUnion2$Outbound;
+}
+
+export function instructionsUnion2ToJSON(
+  instructionsUnion2: InstructionsUnion2,
+): string {
+  return JSON.stringify(
+    InstructionsUnion2$outboundSchema.parse(instructionsUnion2),
+  );
+}
+
+export function instructionsUnion2FromJSON(
+  jsonString: string,
+): SafeParseResult<InstructionsUnion2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => InstructionsUnion2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'InstructionsUnion2' from JSON`,
+  );
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolType$inboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseToolType> = z
+    .nativeEnum(OpenResponsesNonStreamingResponseToolType);
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolType$outboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseToolType> =
+    OpenResponsesNonStreamingResponseToolType$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseToolType$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolType$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseToolType$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolType$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseToolType$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolFunction$inboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseToolFunction,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    type: OpenResponsesNonStreamingResponseToolType$inboundSchema,
+    name: z.string(),
+    description: z.nullable(z.string()).optional(),
+    strict: z.nullable(z.boolean()).optional(),
+    parameters: z.nullable(z.record(z.nullable(z.any()))),
+  });
+
+/** @internal */
+export type OpenResponsesNonStreamingResponseToolFunction$Outbound = {
+  type: string;
+  name: string;
+  description?: string | null | undefined;
+  strict?: boolean | null | undefined;
+  parameters: { [k: string]: any | null } | null;
+};
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolFunction$outboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseToolFunction$Outbound,
+    z.ZodTypeDef,
+    OpenResponsesNonStreamingResponseToolFunction
+  > = z.object({
+    type: OpenResponsesNonStreamingResponseToolType$outboundSchema,
+    name: z.string(),
+    description: z.nullable(z.string()).optional(),
+    strict: z.nullable(z.boolean()).optional(),
+    parameters: z.nullable(z.record(z.nullable(z.any()))),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseToolFunction$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolFunction$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseToolFunction$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolFunction$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseToolFunction$outboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolFunction$Outbound` instead. */
+  export type Outbound = OpenResponsesNonStreamingResponseToolFunction$Outbound;
+}
+
+export function openResponsesNonStreamingResponseToolFunctionToJSON(
+  openResponsesNonStreamingResponseToolFunction:
+    OpenResponsesNonStreamingResponseToolFunction,
+): string {
+  return JSON.stringify(
+    OpenResponsesNonStreamingResponseToolFunction$outboundSchema.parse(
+      openResponsesNonStreamingResponseToolFunction,
+    ),
+  );
+}
+
+export function openResponsesNonStreamingResponseToolFunctionFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  OpenResponsesNonStreamingResponseToolFunction,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      OpenResponsesNonStreamingResponseToolFunction$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'OpenResponsesNonStreamingResponseToolFunction' from JSON`,
+  );
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolUnion$inboundSchema:
+  z.ZodType<OpenResponsesNonStreamingResponseToolUnion, z.ZodTypeDef, unknown> =
+    z.union([
+      z.lazy(() => OpenResponsesNonStreamingResponseToolFunction$inboundSchema),
+      OpenResponsesWebSearchPreviewTool$inboundSchema,
+      OpenResponsesWebSearchPreview20250311Tool$inboundSchema,
+      OpenResponsesWebSearchTool$inboundSchema,
+      OpenResponsesWebSearch20250826Tool$inboundSchema,
+    ]);
+
+/** @internal */
+export type OpenResponsesNonStreamingResponseToolUnion$Outbound =
+  | OpenResponsesNonStreamingResponseToolFunction$Outbound
+  | OpenResponsesWebSearchPreviewTool$Outbound
+  | OpenResponsesWebSearchPreview20250311Tool$Outbound
+  | OpenResponsesWebSearchTool$Outbound
+  | OpenResponsesWebSearch20250826Tool$Outbound;
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolUnion$outboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseToolUnion$Outbound,
+    z.ZodTypeDef,
+    OpenResponsesNonStreamingResponseToolUnion
+  > = z.union([
+    z.lazy(() => OpenResponsesNonStreamingResponseToolFunction$outboundSchema),
+    OpenResponsesWebSearchPreviewTool$outboundSchema,
+    OpenResponsesWebSearchPreview20250311Tool$outboundSchema,
+    OpenResponsesWebSearchTool$outboundSchema,
+    OpenResponsesWebSearch20250826Tool$outboundSchema,
+  ]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseToolUnion$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolUnion$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseToolUnion$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolUnion$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseToolUnion$outboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolUnion$Outbound` instead. */
+  export type Outbound = OpenResponsesNonStreamingResponseToolUnion$Outbound;
+}
+
+export function openResponsesNonStreamingResponseToolUnionToJSON(
+  openResponsesNonStreamingResponseToolUnion:
+    OpenResponsesNonStreamingResponseToolUnion,
+): string {
+  return JSON.stringify(
+    OpenResponsesNonStreamingResponseToolUnion$outboundSchema.parse(
+      openResponsesNonStreamingResponseToolUnion,
+    ),
+  );
+}
+
+export function openResponsesNonStreamingResponseToolUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  OpenResponsesNonStreamingResponseToolUnion,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      OpenResponsesNonStreamingResponseToolUnion$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'OpenResponsesNonStreamingResponseToolUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseTypeWebSearchPreview$inboundSchema:
+  z.ZodNativeEnum<
+    typeof OpenResponsesNonStreamingResponseTypeWebSearchPreview
+  > = z.nativeEnum(OpenResponsesNonStreamingResponseTypeWebSearchPreview);
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseTypeWebSearchPreview$outboundSchema:
+  z.ZodNativeEnum<
+    typeof OpenResponsesNonStreamingResponseTypeWebSearchPreview
+  > = OpenResponsesNonStreamingResponseTypeWebSearchPreview$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseTypeWebSearchPreview$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseTypeWebSearchPreview$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseTypeWebSearchPreview$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseTypeWebSearchPreview$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseTypeWebSearchPreview$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$inboundSchema:
+  z.ZodNativeEnum<
+    typeof OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311
+  > = z.nativeEnum(
+    OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311,
+  );
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$outboundSchema:
+  z.ZodNativeEnum<
+    typeof OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311
+  > =
+    OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseTypeUnion$inboundSchema:
+  z.ZodType<OpenResponsesNonStreamingResponseTypeUnion, z.ZodTypeDef, unknown> =
+    z.union([
+      OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$inboundSchema,
+      OpenResponsesNonStreamingResponseTypeWebSearchPreview$inboundSchema,
+    ]);
+
+/** @internal */
+export type OpenResponsesNonStreamingResponseTypeUnion$Outbound =
+  | string
+  | string;
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseTypeUnion$outboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseTypeUnion$Outbound,
+    z.ZodTypeDef,
+    OpenResponsesNonStreamingResponseTypeUnion
+  > = z.union([
+    OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$outboundSchema,
+    OpenResponsesNonStreamingResponseTypeWebSearchPreview$outboundSchema,
+  ]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseTypeUnion$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseTypeUnion$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseTypeUnion$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseTypeUnion$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseTypeUnion$outboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseTypeUnion$Outbound` instead. */
+  export type Outbound = OpenResponsesNonStreamingResponseTypeUnion$Outbound;
+}
+
+export function openResponsesNonStreamingResponseTypeUnionToJSON(
+  openResponsesNonStreamingResponseTypeUnion:
+    OpenResponsesNonStreamingResponseTypeUnion,
+): string {
+  return JSON.stringify(
+    OpenResponsesNonStreamingResponseTypeUnion$outboundSchema.parse(
+      openResponsesNonStreamingResponseTypeUnion,
+    ),
+  );
+}
+
+export function openResponsesNonStreamingResponseTypeUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  OpenResponsesNonStreamingResponseTypeUnion,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      OpenResponsesNonStreamingResponseTypeUnion$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'OpenResponsesNonStreamingResponseTypeUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoice$inboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseToolChoice,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    type: z.union([
+      OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$inboundSchema,
+      OpenResponsesNonStreamingResponseTypeWebSearchPreview$inboundSchema,
+    ]),
+  });
+
+/** @internal */
+export type OpenResponsesNonStreamingResponseToolChoice$Outbound = {
+  type: string | string;
+};
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoice$outboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseToolChoice$Outbound,
+    z.ZodTypeDef,
+    OpenResponsesNonStreamingResponseToolChoice
+  > = z.object({
+    type: z.union([
+      OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$outboundSchema,
+      OpenResponsesNonStreamingResponseTypeWebSearchPreview$outboundSchema,
+    ]),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseToolChoice$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolChoice$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseToolChoice$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolChoice$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseToolChoice$outboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolChoice$Outbound` instead. */
+  export type Outbound = OpenResponsesNonStreamingResponseToolChoice$Outbound;
+}
+
+export function openResponsesNonStreamingResponseToolChoiceToJSON(
+  openResponsesNonStreamingResponseToolChoice:
+    OpenResponsesNonStreamingResponseToolChoice,
+): string {
+  return JSON.stringify(
+    OpenResponsesNonStreamingResponseToolChoice$outboundSchema.parse(
+      openResponsesNonStreamingResponseToolChoice,
+    ),
+  );
+}
+
+export function openResponsesNonStreamingResponseToolChoiceFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  OpenResponsesNonStreamingResponseToolChoice,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      OpenResponsesNonStreamingResponseToolChoice$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'OpenResponsesNonStreamingResponseToolChoice' from JSON`,
+  );
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceTypeFunction$inboundSchema:
+  z.ZodNativeEnum<
+    typeof OpenResponsesNonStreamingResponseToolChoiceTypeFunction
+  > = z.nativeEnum(OpenResponsesNonStreamingResponseToolChoiceTypeFunction);
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceTypeFunction$outboundSchema:
+  z.ZodNativeEnum<
+    typeof OpenResponsesNonStreamingResponseToolChoiceTypeFunction
+  > = OpenResponsesNonStreamingResponseToolChoiceTypeFunction$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseToolChoiceTypeFunction$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceTypeFunction$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseToolChoiceTypeFunction$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceTypeFunction$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseToolChoiceTypeFunction$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceFunction$inboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseToolChoiceFunction,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    type: OpenResponsesNonStreamingResponseToolChoiceTypeFunction$inboundSchema,
+    name: z.string(),
+  });
+
+/** @internal */
+export type OpenResponsesNonStreamingResponseToolChoiceFunction$Outbound = {
+  type: string;
+  name: string;
+};
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceFunction$outboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseToolChoiceFunction$Outbound,
+    z.ZodTypeDef,
+    OpenResponsesNonStreamingResponseToolChoiceFunction
+  > = z.object({
+    type:
+      OpenResponsesNonStreamingResponseToolChoiceTypeFunction$outboundSchema,
+    name: z.string(),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseToolChoiceFunction$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceFunction$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseToolChoiceFunction$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceFunction$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseToolChoiceFunction$outboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceFunction$Outbound` instead. */
+  export type Outbound =
+    OpenResponsesNonStreamingResponseToolChoiceFunction$Outbound;
+}
+
+export function openResponsesNonStreamingResponseToolChoiceFunctionToJSON(
+  openResponsesNonStreamingResponseToolChoiceFunction:
+    OpenResponsesNonStreamingResponseToolChoiceFunction,
+): string {
+  return JSON.stringify(
+    OpenResponsesNonStreamingResponseToolChoiceFunction$outboundSchema.parse(
+      openResponsesNonStreamingResponseToolChoiceFunction,
+    ),
+  );
+}
+
+export function openResponsesNonStreamingResponseToolChoiceFunctionFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  OpenResponsesNonStreamingResponseToolChoiceFunction,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      OpenResponsesNonStreamingResponseToolChoiceFunction$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'OpenResponsesNonStreamingResponseToolChoiceFunction' from JSON`,
+  );
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceRequired$inboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseToolChoiceRequired> =
+    z.nativeEnum(OpenResponsesNonStreamingResponseToolChoiceRequired);
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceRequired$outboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseToolChoiceRequired> =
+    OpenResponsesNonStreamingResponseToolChoiceRequired$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseToolChoiceRequired$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceRequired$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseToolChoiceRequired$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceRequired$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseToolChoiceRequired$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceNone$inboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseToolChoiceNone> = z
+    .nativeEnum(OpenResponsesNonStreamingResponseToolChoiceNone);
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceNone$outboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseToolChoiceNone> =
+    OpenResponsesNonStreamingResponseToolChoiceNone$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseToolChoiceNone$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceNone$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseToolChoiceNone$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceNone$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseToolChoiceNone$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceAuto$inboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseToolChoiceAuto> = z
+    .nativeEnum(OpenResponsesNonStreamingResponseToolChoiceAuto);
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceAuto$outboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesNonStreamingResponseToolChoiceAuto> =
+    OpenResponsesNonStreamingResponseToolChoiceAuto$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseToolChoiceAuto$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceAuto$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseToolChoiceAuto$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceAuto$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseToolChoiceAuto$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceUnion$inboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseToolChoiceUnion,
+    z.ZodTypeDef,
+    unknown
+  > = z.union([
+    z.lazy(() =>
+      OpenResponsesNonStreamingResponseToolChoiceFunction$inboundSchema
+    ),
+    z.lazy(() => OpenResponsesNonStreamingResponseToolChoice$inboundSchema),
+    OpenResponsesNonStreamingResponseToolChoiceAuto$inboundSchema,
+    OpenResponsesNonStreamingResponseToolChoiceNone$inboundSchema,
+    OpenResponsesNonStreamingResponseToolChoiceRequired$inboundSchema,
+  ]);
+
+/** @internal */
+export type OpenResponsesNonStreamingResponseToolChoiceUnion$Outbound =
+  | OpenResponsesNonStreamingResponseToolChoiceFunction$Outbound
+  | OpenResponsesNonStreamingResponseToolChoice$Outbound
+  | string
+  | string
+  | string;
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceUnion$outboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseToolChoiceUnion$Outbound,
+    z.ZodTypeDef,
+    OpenResponsesNonStreamingResponseToolChoiceUnion
+  > = z.union([
+    z.lazy(() =>
+      OpenResponsesNonStreamingResponseToolChoiceFunction$outboundSchema
+    ),
+    z.lazy(() => OpenResponsesNonStreamingResponseToolChoice$outboundSchema),
+    OpenResponsesNonStreamingResponseToolChoiceAuto$outboundSchema,
+    OpenResponsesNonStreamingResponseToolChoiceNone$outboundSchema,
+    OpenResponsesNonStreamingResponseToolChoiceRequired$outboundSchema,
+  ]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseToolChoiceUnion$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceUnion$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseToolChoiceUnion$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceUnion$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseToolChoiceUnion$outboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceUnion$Outbound` instead. */
+  export type Outbound =
+    OpenResponsesNonStreamingResponseToolChoiceUnion$Outbound;
+}
+
+export function openResponsesNonStreamingResponseToolChoiceUnionToJSON(
+  openResponsesNonStreamingResponseToolChoiceUnion:
+    OpenResponsesNonStreamingResponseToolChoiceUnion,
+): string {
+  return JSON.stringify(
+    OpenResponsesNonStreamingResponseToolChoiceUnion$outboundSchema.parse(
+      openResponsesNonStreamingResponseToolChoiceUnion,
+    ),
+  );
+}
+
+export function openResponsesNonStreamingResponseToolChoiceUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  OpenResponsesNonStreamingResponseToolChoiceUnion,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      OpenResponsesNonStreamingResponseToolChoiceUnion$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'OpenResponsesNonStreamingResponseToolChoiceUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseEffort$inboundSchema: z.ZodType<
+  OpenResponsesNonStreamingResponseEffort,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(OpenResponsesNonStreamingResponseEffort),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseEffort$outboundSchema: z.ZodType<
+  OpenResponsesNonStreamingResponseEffort,
+  z.ZodTypeDef,
+  OpenResponsesNonStreamingResponseEffort
+> = z.union([
+  z.nativeEnum(OpenResponsesNonStreamingResponseEffort),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseEffort$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseEffort$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseEffort$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseEffort$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseEffort$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseReasoning$inboundSchema:
+  z.ZodType<OpenResponsesNonStreamingResponseReasoning, z.ZodTypeDef, unknown> =
+    z.object({
+      effort: z.nullable(OpenResponsesNonStreamingResponseEffort$inboundSchema)
+        .optional(),
+      summary: ReasoningSummaryVerbosity$inboundSchema.optional(),
+    });
+
+/** @internal */
+export type OpenResponsesNonStreamingResponseReasoning$Outbound = {
+  effort?: string | null | undefined;
+  summary?: string | undefined;
+};
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseReasoning$outboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseReasoning$Outbound,
+    z.ZodTypeDef,
+    OpenResponsesNonStreamingResponseReasoning
+  > = z.object({
+    effort: z.nullable(OpenResponsesNonStreamingResponseEffort$outboundSchema)
+      .optional(),
+    summary: ReasoningSummaryVerbosity$outboundSchema.optional(),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseReasoning$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseReasoning$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseReasoning$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseReasoning$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseReasoning$outboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseReasoning$Outbound` instead. */
+  export type Outbound = OpenResponsesNonStreamingResponseReasoning$Outbound;
+}
+
+export function openResponsesNonStreamingResponseReasoningToJSON(
+  openResponsesNonStreamingResponseReasoning:
+    OpenResponsesNonStreamingResponseReasoning,
+): string {
+  return JSON.stringify(
+    OpenResponsesNonStreamingResponseReasoning$outboundSchema.parse(
+      openResponsesNonStreamingResponseReasoning,
+    ),
+  );
+}
+
+export function openResponsesNonStreamingResponseReasoningFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  OpenResponsesNonStreamingResponseReasoning,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      OpenResponsesNonStreamingResponseReasoning$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'OpenResponsesNonStreamingResponseReasoning' from JSON`,
+  );
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseServiceTier$inboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseServiceTier,
+    z.ZodTypeDef,
+    unknown
+  > = z
+    .union([
+      z.nativeEnum(OpenResponsesNonStreamingResponseServiceTier),
+      z.string().transform(catchUnrecognizedEnum),
+    ]);
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseServiceTier$outboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseServiceTier,
+    z.ZodTypeDef,
+    OpenResponsesNonStreamingResponseServiceTier
+  > = z.union([
+    z.nativeEnum(OpenResponsesNonStreamingResponseServiceTier),
+    z.string().and(z.custom<Unrecognized<string>>()),
+  ]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseServiceTier$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseServiceTier$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseServiceTier$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseServiceTier$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseServiceTier$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseTruncation$inboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseTruncation,
+    z.ZodTypeDef,
+    unknown
+  > = z
+    .union([
+      z.nativeEnum(OpenResponsesNonStreamingResponseTruncation),
+      z.string().transform(catchUnrecognizedEnum),
+    ]);
+
+/** @internal */
+export const OpenResponsesNonStreamingResponseTruncation$outboundSchema:
+  z.ZodType<
+    OpenResponsesNonStreamingResponseTruncation,
+    z.ZodTypeDef,
+    OpenResponsesNonStreamingResponseTruncation
+  > = z.union([
+    z.nativeEnum(OpenResponsesNonStreamingResponseTruncation),
+    z.string().and(z.custom<Unrecognized<string>>()),
+  ]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesNonStreamingResponseTruncation$ {
+  /** @deprecated use `OpenResponsesNonStreamingResponseTruncation$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesNonStreamingResponseTruncation$inboundSchema;
+  /** @deprecated use `OpenResponsesNonStreamingResponseTruncation$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesNonStreamingResponseTruncation$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesNonStreamingResponse$inboundSchema: z.ZodType<
+  OpenResponsesNonStreamingResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  object: ObjectT$inboundSchema,
+  created_at: z.number(),
+  model: z.string(),
+  status: OpenResponsesNonStreamingResponseStatus$inboundSchema.optional(),
+  output: z.array(ResponsesOutputItem$inboundSchema),
+  user: z.nullable(z.string()).optional(),
+  output_text: z.string().optional(),
+  prompt_cache_key: z.nullable(z.string()).optional(),
+  safety_identifier: z.nullable(z.string()).optional(),
+  error: z.nullable(ResponsesErrorField$inboundSchema),
+  incomplete_details: z.nullable(z.lazy(() => IncompleteDetails$inboundSchema)),
+  usage: z.lazy(() => Usage$inboundSchema).optional(),
+  max_tool_calls: z.nullable(z.number()).optional(),
+  top_logprobs: z.number().optional(),
+  max_output_tokens: z.nullable(z.number()).optional(),
+  temperature: z.nullable(z.number()),
+  top_p: z.nullable(z.number()),
+  instructions: z.nullable(
+    z.union([
+      z.string(),
+      z.array(
+        z.union([
+          z.lazy(() => InstructionsFunctionCallOutput$inboundSchema),
+          z.lazy(() => InstructionsFunctionCall$inboundSchema),
+          OutputItemImageGenerationCall$inboundSchema,
+          OutputMessage$inboundSchema,
+          z.lazy(() => InstructionsMessage2$inboundSchema),
+          z.lazy(() => InstructionsMessage1$inboundSchema),
+        ]),
+      ),
+      z.any(),
+    ]),
+  ).optional(),
+  metadata: z.nullable(z.record(z.string())),
+  tools: z.array(
+    z.union([
+      z.lazy(() => OpenResponsesNonStreamingResponseToolFunction$inboundSchema),
+      OpenResponsesWebSearchPreviewTool$inboundSchema,
+      OpenResponsesWebSearchPreview20250311Tool$inboundSchema,
+      OpenResponsesWebSearchTool$inboundSchema,
+      OpenResponsesWebSearch20250826Tool$inboundSchema,
+    ]),
+  ),
+  tool_choice: z.union([
+    z.lazy(() =>
+      OpenResponsesNonStreamingResponseToolChoiceFunction$inboundSchema
+    ),
+    z.lazy(() => OpenResponsesNonStreamingResponseToolChoice$inboundSchema),
+    OpenResponsesNonStreamingResponseToolChoiceAuto$inboundSchema,
+    OpenResponsesNonStreamingResponseToolChoiceNone$inboundSchema,
+    OpenResponsesNonStreamingResponseToolChoiceRequired$inboundSchema,
+  ]),
+  parallel_tool_calls: z.boolean(),
+  prompt: z.nullable(OpenAIResponsesPrompt$inboundSchema).optional(),
+  background: z.nullable(z.boolean()).optional(),
+  previous_response_id: z.nullable(z.string()).optional(),
+  reasoning: z.nullable(
+    z.lazy(() => OpenResponsesNonStreamingResponseReasoning$inboundSchema),
+  ).optional(),
+  service_tier: z.nullable(
+    OpenResponsesNonStreamingResponseServiceTier$inboundSchema,
+  ).optional(),
+  store: z.boolean().optional(),
+  truncation: z.nullable(
+    OpenResponsesNonStreamingResponseTruncation$inboundSchema,
+  ).optional(),
+  text: ResponseTextConfig$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "created_at": "createdAt",
+    "output_text": "outputText",
+    "prompt_cache_key": "promptCacheKey",
+    "safety_identifier": "safetyIdentifier",
+    "incomplete_details": "incompleteDetails",
+    "max_tool_calls": "maxToolCalls",
+    "top_logprobs": "topLogprobs",
+    "max_output_tokens": "maxOutputTokens",
+    "top_p": "topP",
+    "tool_choice": "toolChoice",
+    "parallel_tool_calls": "parallelToolCalls",
+    "previous_response_id": "previousResponseId",
+    "service_tier": "serviceTier",
+  });
+});
+
+/** @internal */
+export type OpenResponsesNonStreamingResponse$Outbound = {
+  id: string;
+  object: string;
+  created_at: number;
+  model: string;
+  status?: string | undefined;
+  output: Array<ResponsesOutputItem$Outbound>;
+  user?: string | null | undefined;
+  output_text?: string | undefined;
+  prompt_cache_key?: string | null | undefined;
+  safety_identifier?: string | null | undefined;
+  error: ResponsesErrorField$Outbound | null;
   incomplete_details: IncompleteDetails$Outbound | null;
-  usage?: ResponsesUsage$Outbound | undefined;
+  usage?: Usage$Outbound | undefined;
   max_tool_calls?: number | null | undefined;
   top_logprobs?: number | undefined;
   max_output_tokens?: number | null | undefined;
   temperature: number | null;
   top_p: number | null;
-  instructions?: OpenResponsesInput$Outbound | null | undefined;
+  instructions?:
+    | string
+    | Array<
+      | InstructionsFunctionCallOutput$Outbound
+      | InstructionsFunctionCall$Outbound
+      | OutputItemImageGenerationCall$Outbound
+      | OutputMessage$Outbound
+      | InstructionsMessage2$Outbound
+      | InstructionsMessage1$Outbound
+    >
+    | any
+    | null
+    | undefined;
   metadata: { [k: string]: string } | null;
-  tools: Array<OpenResponsesToolUnion$Outbound>;
-  tool_choice: OpenResponsesToolChoice$Outbound;
+  tools: Array<
+    | OpenResponsesNonStreamingResponseToolFunction$Outbound
+    | OpenResponsesWebSearchPreviewTool$Outbound
+    | OpenResponsesWebSearchPreview20250311Tool$Outbound
+    | OpenResponsesWebSearchTool$Outbound
+    | OpenResponsesWebSearch20250826Tool$Outbound
+  >;
+  tool_choice:
+    | OpenResponsesNonStreamingResponseToolChoiceFunction$Outbound
+    | OpenResponsesNonStreamingResponseToolChoice$Outbound
+    | string
+    | string
+    | string;
   parallel_tool_calls: boolean;
-  prompt?: OpenResponsesPrompt$Outbound | null | undefined;
+  prompt?: OpenAIResponsesPrompt$Outbound | null | undefined;
   background?: boolean | null | undefined;
   previous_response_id?: string | null | undefined;
-  reasoning?: OpenResponsesReasoningConfig$Outbound | null | undefined;
+  reasoning?:
+    | OpenResponsesNonStreamingResponseReasoning$Outbound
+    | null
+    | undefined;
   service_tier?: string | null | undefined;
   store?: boolean | undefined;
   truncation?: string | null | undefined;
-  text?: OpenResponsesTextConfig$Outbound | undefined;
+  text?: ResponseTextConfig$Outbound | undefined;
 };
 
 /** @internal */
@@ -463,7 +3014,7 @@ export const OpenResponsesNonStreamingResponse$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   OpenResponsesNonStreamingResponse
 > = z.object({
-  id: z.string().optional(),
+  id: z.string(),
   object: ObjectT$outboundSchema,
   createdAt: z.number(),
   model: z.string(),
@@ -475,25 +3026,64 @@ export const OpenResponsesNonStreamingResponse$outboundSchema: z.ZodType<
   safetyIdentifier: z.nullable(z.string()).optional(),
   error: z.nullable(ResponsesErrorField$outboundSchema),
   incompleteDetails: z.nullable(z.lazy(() => IncompleteDetails$outboundSchema)),
-  usage: ResponsesUsage$outboundSchema.optional(),
+  usage: z.lazy(() => Usage$outboundSchema).optional(),
   maxToolCalls: z.nullable(z.number()).optional(),
   topLogprobs: z.number().optional(),
   maxOutputTokens: z.nullable(z.number()).optional(),
   temperature: z.nullable(z.number()),
   topP: z.nullable(z.number()),
-  instructions: z.nullable(OpenResponsesInput$outboundSchema).optional(),
+  instructions: z.nullable(
+    z.union([
+      z.string(),
+      z.array(
+        z.union([
+          z.lazy(() => InstructionsFunctionCallOutput$outboundSchema),
+          z.lazy(() => InstructionsFunctionCall$outboundSchema),
+          OutputItemImageGenerationCall$outboundSchema,
+          OutputMessage$outboundSchema,
+          z.lazy(() => InstructionsMessage2$outboundSchema),
+          z.lazy(() => InstructionsMessage1$outboundSchema),
+        ]),
+      ),
+      z.any(),
+    ]),
+  ).optional(),
   metadata: z.nullable(z.record(z.string())),
-  tools: z.array(OpenResponsesToolUnion$outboundSchema),
-  toolChoice: OpenResponsesToolChoice$outboundSchema,
+  tools: z.array(
+    z.union([
+      z.lazy(() =>
+        OpenResponsesNonStreamingResponseToolFunction$outboundSchema
+      ),
+      OpenResponsesWebSearchPreviewTool$outboundSchema,
+      OpenResponsesWebSearchPreview20250311Tool$outboundSchema,
+      OpenResponsesWebSearchTool$outboundSchema,
+      OpenResponsesWebSearch20250826Tool$outboundSchema,
+    ]),
+  ),
+  toolChoice: z.union([
+    z.lazy(() =>
+      OpenResponsesNonStreamingResponseToolChoiceFunction$outboundSchema
+    ),
+    z.lazy(() => OpenResponsesNonStreamingResponseToolChoice$outboundSchema),
+    OpenResponsesNonStreamingResponseToolChoiceAuto$outboundSchema,
+    OpenResponsesNonStreamingResponseToolChoiceNone$outboundSchema,
+    OpenResponsesNonStreamingResponseToolChoiceRequired$outboundSchema,
+  ]),
   parallelToolCalls: z.boolean(),
-  prompt: z.nullable(OpenResponsesPrompt$outboundSchema).optional(),
+  prompt: z.nullable(OpenAIResponsesPrompt$outboundSchema).optional(),
   background: z.nullable(z.boolean()).optional(),
   previousResponseId: z.nullable(z.string()).optional(),
-  reasoning: z.nullable(OpenResponsesReasoningConfig$outboundSchema).optional(),
-  serviceTier: z.nullable(ServiceTier$outboundSchema).optional(),
+  reasoning: z.nullable(
+    z.lazy(() => OpenResponsesNonStreamingResponseReasoning$outboundSchema),
+  ).optional(),
+  serviceTier: z.nullable(
+    OpenResponsesNonStreamingResponseServiceTier$outboundSchema,
+  ).optional(),
   store: z.boolean().optional(),
-  truncation: z.nullable(Truncation$outboundSchema).optional(),
-  text: OpenResponsesTextConfig$outboundSchema.optional(),
+  truncation: z.nullable(
+    OpenResponsesNonStreamingResponseTruncation$outboundSchema,
+  ).optional(),
+  text: ResponseTextConfig$outboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     createdAt: "created_at",