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

package/src/models/openresponsesnonstreamingresponse.ts

@@ -14,70 +14,41 @@ import {
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import {
-  OpenAIResponsesPrompt,
-  OpenAIResponsesPrompt$inboundSchema,
-  OpenAIResponsesPrompt$Outbound,
-  OpenAIResponsesPrompt$outboundSchema,
-} from "./openairesponsesprompt.js";
+  OpenResponsesInput,
+  OpenResponsesInput$inboundSchema,
+  OpenResponsesInput$Outbound,
+  OpenResponsesInput$outboundSchema,
+} from "./openresponsesinput.js";
 import {
-  OpenResponsesWebSearch20250826Tool,
-  OpenResponsesWebSearch20250826Tool$inboundSchema,
-  OpenResponsesWebSearch20250826Tool$Outbound,
-  OpenResponsesWebSearch20250826Tool$outboundSchema,
-} from "./openresponseswebsearch20250826tool.js";
+  OpenResponsesPrompt,
+  OpenResponsesPrompt$inboundSchema,
+  OpenResponsesPrompt$Outbound,
+  OpenResponsesPrompt$outboundSchema,
+} from "./openresponsesprompt.js";
 import {
-  OpenResponsesWebSearchPreview20250311Tool,
-  OpenResponsesWebSearchPreview20250311Tool$inboundSchema,
-  OpenResponsesWebSearchPreview20250311Tool$Outbound,
-  OpenResponsesWebSearchPreview20250311Tool$outboundSchema,
-} from "./openresponseswebsearchpreview20250311tool.js";
+  OpenResponsesReasoningConfig,
+  OpenResponsesReasoningConfig$inboundSchema,
+  OpenResponsesReasoningConfig$Outbound,
+  OpenResponsesReasoningConfig$outboundSchema,
+} from "./openresponsesreasoningconfig.js";
 import {
-  OpenResponsesWebSearchPreviewTool,
-  OpenResponsesWebSearchPreviewTool$inboundSchema,
-  OpenResponsesWebSearchPreviewTool$Outbound,
-  OpenResponsesWebSearchPreviewTool$outboundSchema,
-} from "./openresponseswebsearchpreviewtool.js";
+  OpenResponsesTextConfig,
+  OpenResponsesTextConfig$inboundSchema,
+  OpenResponsesTextConfig$Outbound,
+  OpenResponsesTextConfig$outboundSchema,
+} from "./openresponsestextconfig.js";
 import {
-  OpenResponsesWebSearchTool,
-  OpenResponsesWebSearchTool$inboundSchema,
-  OpenResponsesWebSearchTool$Outbound,
-  OpenResponsesWebSearchTool$outboundSchema,
-} from "./openresponseswebsearchtool.js";
+  OpenResponsesToolChoice,
+  OpenResponsesToolChoice$inboundSchema,
+  OpenResponsesToolChoice$Outbound,
+  OpenResponsesToolChoice$outboundSchema,
+} from "./openresponsestoolchoice.js";
 import {
-  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";
+  OpenResponsesToolUnion,
+  OpenResponsesToolUnion$inboundSchema,
+  OpenResponsesToolUnion$Outbound,
+  OpenResponsesToolUnion$outboundSchema,
+} from "./openresponsestoolunion.js";
 import {
   ResponsesErrorField,
   ResponsesErrorField$inboundSchema,
@@ -91,16 +62,11 @@ import {
   ResponsesOutputItem$outboundSchema,
 } from "./responsesoutputitem.js";
 import {
-  ResponseTextConfig,
-  ResponseTextConfig$inboundSchema,
-  ResponseTextConfig$Outbound,
-  ResponseTextConfig$outboundSchema,
-} from "./responsetextconfig.js";
-import {
-  ToolCallStatus,
-  ToolCallStatus$inboundSchema,
-  ToolCallStatus$outboundSchema,
-} from "./toolcallstatus.js";
+  ResponsesUsage,
+  ResponsesUsage$inboundSchema,
+  ResponsesUsage$Outbound,
+  ResponsesUsage$outboundSchema,
+} from "./responsesusage.js";
 
 export const ObjectT = {
   Response: "response",
@@ -129,323 +95,26 @@ export type IncompleteDetails = {
   reason?: Reason | undefined;
 };
 
-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 = {
+export const ServiceTier = {
   Auto: "auto",
   Default: "default",
   Flex: "flex",
   Priority: "priority",
   Scale: "scale",
 } as const;
-export type OpenResponsesNonStreamingResponseServiceTier = OpenEnum<
-  typeof OpenResponsesNonStreamingResponseServiceTier
->;
+export type ServiceTier = OpenEnum<typeof ServiceTier>;
 
-export const OpenResponsesNonStreamingResponseTruncation = {
+export const Truncation = {
   Auto: "auto",
   Disabled: "disabled",
 } as const;
-export type OpenResponsesNonStreamingResponseTruncation = OpenEnum<
-  typeof OpenResponsesNonStreamingResponseTruncation
->;
+export type Truncation = OpenEnum<typeof Truncation>;
 
 /**
  * Complete non-streaming response from the Responses API
  */
 export type OpenResponsesNonStreamingResponse = {
-  id: string;
+  id?: string | undefined;
   object: ObjectT;
   createdAt: number;
   model: string;
@@ -460,54 +129,46 @@ export type OpenResponsesNonStreamingResponse = {
    */
   error: ResponsesErrorField | null;
   incompleteDetails: IncompleteDetails | null;
-  usage?: Usage | undefined;
+  /**
+   * Token usage information for the response
+   */
+  usage?: ResponsesUsage | undefined;
   maxToolCalls?: number | null | undefined;
   topLogprobs?: number | undefined;
   maxOutputTokens?: number | null | undefined;
   temperature: number | null;
   topP: number | null;
-  instructions?:
-    | string
-    | Array<
-      | InstructionsFunctionCallOutput
-      | InstructionsFunctionCall
-      | OutputItemImageGenerationCall
-      | OutputMessage
-      | InstructionsMessage2
-      | InstructionsMessage1
-    >
-    | any
-    | null
-    | undefined;
+  /**
+   * Input for a response request - can be a string or array of items
+   */
+  instructions?: OpenResponsesInput | 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<
-    | OpenResponsesNonStreamingResponseToolFunction
-    | OpenResponsesWebSearchPreviewTool
-    | OpenResponsesWebSearchPreview20250311Tool
-    | OpenResponsesWebSearchTool
-    | OpenResponsesWebSearch20250826Tool
-  >;
-  toolChoice:
-    | OpenResponsesNonStreamingResponseToolChoiceFunction
-    | OpenResponsesNonStreamingResponseToolChoice
-    | OpenResponsesNonStreamingResponseToolChoiceAuto
-    | OpenResponsesNonStreamingResponseToolChoiceNone
-    | OpenResponsesNonStreamingResponseToolChoiceRequired;
+  tools: Array<OpenResponsesToolUnion>;
+  /**
+   * Controls which tool the model should call
+   */
+  toolChoice: OpenResponsesToolChoice;
   parallelToolCalls: boolean;
-  prompt?: OpenAIResponsesPrompt | null | undefined;
+  /**
+   * Prompt template with variables for the response
+   */
+  prompt?: OpenResponsesPrompt | null | undefined;
   background?: boolean | null | undefined;
   previousResponseId?: string | null | undefined;
-  reasoning?: OpenResponsesNonStreamingResponseReasoning | null | undefined;
-  serviceTier?: OpenResponsesNonStreamingResponseServiceTier | null | undefined;
+  /**
+   * Configuration for reasoning mode in the response
+   */
+  reasoning?: OpenResponsesReasoningConfig | null | undefined;
+  serviceTier?: ServiceTier | null | undefined;
   store?: boolean | undefined;
-  truncation?: OpenResponsesNonStreamingResponseTruncation | null | undefined;
+  truncation?: Truncation | null | undefined;
   /**
    * Text output configuration including format and verbosity
    */
-  text?: ResponseTextConfig | undefined;
+  text?: OpenResponsesTextConfig | undefined;
 };
 
 /** @internal */
@@ -643,2316 +304,130 @@ export function incompleteDetailsFromJSON(
 }
 
 /** @internal */
-export const InputTokensDetails$inboundSchema: z.ZodType<
-  InputTokensDetails,
+export const ServiceTier$inboundSchema: z.ZodType<
+  ServiceTier,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  cached_tokens: z.number(),
-}).transform((v) => {
-  return remap$(v, {
-    "cached_tokens": "cachedTokens",
-  });
-});
-
-/** @internal */
-export type InputTokensDetails$Outbound = {
-  cached_tokens: number;
-};
+> = z
+  .union([
+    z.nativeEnum(ServiceTier),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const InputTokensDetails$outboundSchema: z.ZodType<
-  InputTokensDetails$Outbound,
+export const ServiceTier$outboundSchema: z.ZodType<
+  ServiceTier,
   z.ZodTypeDef,
-  InputTokensDetails
-> = z.object({
-  cachedTokens: z.number(),
-}).transform((v) => {
-  return remap$(v, {
-    cachedTokens: "cached_tokens",
-  });
-});
+  ServiceTier
+> = z.union([
+  z.nativeEnum(ServiceTier),
+  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 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`,
-  );
+export namespace ServiceTier$ {
+  /** @deprecated use `ServiceTier$inboundSchema` instead. */
+  export const inboundSchema = ServiceTier$inboundSchema;
+  /** @deprecated use `ServiceTier$outboundSchema` instead. */
+  export const outboundSchema = ServiceTier$outboundSchema;
 }
 
 /** @internal */
-export const OutputTokensDetails$inboundSchema: z.ZodType<
-  OutputTokensDetails,
+export const Truncation$inboundSchema: z.ZodType<
+  Truncation,
   z.ZodTypeDef,
   unknown
-> = 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 OutputTokensDetails$outboundSchema: z.ZodType<
-  OutputTokensDetails$Outbound,
-  z.ZodTypeDef,
-  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 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 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;
-};
+> = z
+  .union([
+    z.nativeEnum(Truncation),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const Usage$outboundSchema: z.ZodType<
-  Usage$Outbound,
+export const Truncation$outboundSchema: z.ZodType<
+  Truncation,
   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;
+  Truncation
+> = z.union([
+  z.nativeEnum(Truncation),
+  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 InstructionsTypeFunctionCall$ {
-  /** @deprecated use `InstructionsTypeFunctionCall$inboundSchema` instead. */
-  export const inboundSchema = InstructionsTypeFunctionCall$inboundSchema;
-  /** @deprecated use `InstructionsTypeFunctionCall$outboundSchema` instead. */
-  export const outboundSchema = InstructionsTypeFunctionCall$outboundSchema;
+export namespace Truncation$ {
+  /** @deprecated use `Truncation$inboundSchema` instead. */
+  export const inboundSchema = Truncation$inboundSchema;
+  /** @deprecated use `Truncation$outboundSchema` instead. */
+  export const outboundSchema = Truncation$outboundSchema;
 }
 
 /** @internal */
-export const InstructionsFunctionCall$inboundSchema: z.ZodType<
-  InstructionsFunctionCall,
+export const OpenResponsesNonStreamingResponse$inboundSchema: z.ZodType<
+  OpenResponsesNonStreamingResponse,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: InstructionsTypeFunctionCall$inboundSchema,
-  call_id: z.string(),
-  name: z.string(),
-  arguments: z.string(),
   id: z.string().optional(),
-  status: ToolCallStatus$inboundSchema.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(),
 }).transform((v) => {
   return remap$(v, {
-    "call_id": "callId",
+    "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 InstructionsFunctionCall$Outbound = {
-  type: string;
-  call_id: string;
-  name: string;
-  arguments: string;
+export type OpenResponsesNonStreamingResponse$Outbound = {
   id?: string | undefined;
-  status?: string | undefined;
-};
-
-/** @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;
+  object: string;
+  created_at: number;
+  model: string;
   status?: string | undefined;
   output: Array<ResponsesOutputItem$Outbound>;
   user?: string | null | undefined;
@@ -2961,51 +436,25 @@ export type OpenResponsesNonStreamingResponse$Outbound = {
   safety_identifier?: string | null | undefined;
   error: ResponsesErrorField$Outbound | null;
   incomplete_details: IncompleteDetails$Outbound | null;
-  usage?: Usage$Outbound | undefined;
+  usage?: ResponsesUsage$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?:
-    | string
-    | Array<
-      | InstructionsFunctionCallOutput$Outbound
-      | InstructionsFunctionCall$Outbound
-      | OutputItemImageGenerationCall$Outbound
-      | OutputMessage$Outbound
-      | InstructionsMessage2$Outbound
-      | InstructionsMessage1$Outbound
-    >
-    | any
-    | null
-    | undefined;
+  instructions?: OpenResponsesInput$Outbound | null | undefined;
   metadata: { [k: string]: string } | null;
-  tools: Array<
-    | OpenResponsesNonStreamingResponseToolFunction$Outbound
-    | OpenResponsesWebSearchPreviewTool$Outbound
-    | OpenResponsesWebSearchPreview20250311Tool$Outbound
-    | OpenResponsesWebSearchTool$Outbound
-    | OpenResponsesWebSearch20250826Tool$Outbound
-  >;
-  tool_choice:
-    | OpenResponsesNonStreamingResponseToolChoiceFunction$Outbound
-    | OpenResponsesNonStreamingResponseToolChoice$Outbound
-    | string
-    | string
-    | string;
+  tools: Array<OpenResponsesToolUnion$Outbound>;
+  tool_choice: OpenResponsesToolChoice$Outbound;
   parallel_tool_calls: boolean;
-  prompt?: OpenAIResponsesPrompt$Outbound | null | undefined;
+  prompt?: OpenResponsesPrompt$Outbound | null | undefined;
   background?: boolean | null | undefined;
   previous_response_id?: string | null | undefined;
-  reasoning?:
-    | OpenResponsesNonStreamingResponseReasoning$Outbound
-    | null
-    | undefined;
+  reasoning?: OpenResponsesReasoningConfig$Outbound | null | undefined;
   service_tier?: string | null | undefined;
   store?: boolean | undefined;
   truncation?: string | null | undefined;
-  text?: ResponseTextConfig$Outbound | undefined;
+  text?: OpenResponsesTextConfig$Outbound | undefined;
 };
 
 /** @internal */
@@ -3014,7 +463,7 @@ export const OpenResponsesNonStreamingResponse$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   OpenResponsesNonStreamingResponse
 > = z.object({
-  id: z.string(),
+  id: z.string().optional(),
   object: ObjectT$outboundSchema,
   createdAt: z.number(),
   model: z.string(),
@@ -3026,64 +475,25 @@ 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: z.lazy(() => Usage$outboundSchema).optional(),
+  usage: ResponsesUsage$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(
-    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(),
+  instructions: z.nullable(OpenResponsesInput$outboundSchema).optional(),
   metadata: z.nullable(z.record(z.string())),
-  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,
-  ]),
+  tools: z.array(OpenResponsesToolUnion$outboundSchema),
+  toolChoice: OpenResponsesToolChoice$outboundSchema,
   parallelToolCalls: z.boolean(),
-  prompt: z.nullable(OpenAIResponsesPrompt$outboundSchema).optional(),
+  prompt: z.nullable(OpenResponsesPrompt$outboundSchema).optional(),
   background: z.nullable(z.boolean()).optional(),
   previousResponseId: z.nullable(z.string()).optional(),
-  reasoning: z.nullable(
-    z.lazy(() => OpenResponsesNonStreamingResponseReasoning$outboundSchema),
-  ).optional(),
-  serviceTier: z.nullable(
-    OpenResponsesNonStreamingResponseServiceTier$outboundSchema,
-  ).optional(),
+  reasoning: z.nullable(OpenResponsesReasoningConfig$outboundSchema).optional(),
+  serviceTier: z.nullable(ServiceTier$outboundSchema).optional(),
   store: z.boolean().optional(),
-  truncation: z.nullable(
-    OpenResponsesNonStreamingResponseTruncation$outboundSchema,
-  ).optional(),
-  text: ResponseTextConfig$outboundSchema.optional(),
+  truncation: z.nullable(Truncation$outboundSchema).optional(),
+  text: OpenResponsesTextConfig$outboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     createdAt: "created_at",