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

package/src/models/responsesoutputitem.ts

@@ -14,29 +14,17 @@ import {
   ImageGenerationStatus$outboundSchema,
 } from "./imagegenerationstatus.js";
 import {
-  OutputTextContent,
-  OutputTextContent$inboundSchema,
-  OutputTextContent$Outbound,
-  OutputTextContent$outboundSchema,
-} from "./outputtextcontent.js";
+  OpenResponsesOutputItemReasoning,
+  OpenResponsesOutputItemReasoning$inboundSchema,
+  OpenResponsesOutputItemReasoning$Outbound,
+  OpenResponsesOutputItemReasoning$outboundSchema,
+} from "./openresponsesoutputitemreasoning.js";
 import {
-  ReasoningSummaryText,
-  ReasoningSummaryText$inboundSchema,
-  ReasoningSummaryText$Outbound,
-  ReasoningSummaryText$outboundSchema,
-} from "./reasoningsummarytext.js";
-import {
-  ReasoningTextContent,
-  ReasoningTextContent$inboundSchema,
-  ReasoningTextContent$Outbound,
-  ReasoningTextContent$outboundSchema,
-} from "./reasoningtextcontent.js";
-import {
-  RefusalContent,
-  RefusalContent$inboundSchema,
-  RefusalContent$Outbound,
-  RefusalContent$outboundSchema,
-} from "./refusalcontent.js";
+  OpenResponsesOutputMessage,
+  OpenResponsesOutputMessage$inboundSchema,
+  OpenResponsesOutputMessage$Outbound,
+  OpenResponsesOutputMessage$outboundSchema,
+} from "./openresponsesoutputmessage.js";
 import {
   WebSearchStatus,
   WebSearchStatus$inboundSchema,
@@ -91,43 +79,6 @@ export type ResponsesOutputItemTypeFunctionCall = ClosedEnum<
   typeof ResponsesOutputItemTypeFunctionCall
 >;
 
-export type ResponsesOutputItemFunctionCall = {
-  type: ResponsesOutputItemTypeFunctionCall;
-  id?: string | undefined;
-  name: string;
-  arguments: string;
-  callId: string;
-};
-
-export const ResponsesOutputItemTypeReasoning = {
-  Reasoning: "reasoning",
-} as const;
-export type ResponsesOutputItemTypeReasoning = ClosedEnum<
-  typeof ResponsesOutputItemTypeReasoning
->;
-
-export type ResponsesOutputItemReasoning = {
-  type: ResponsesOutputItemTypeReasoning;
-  id: string;
-  content?: Array<ReasoningTextContent> | undefined;
-  summary: Array<ReasoningSummaryText>;
-  encryptedContent?: string | null | undefined;
-};
-
-export const ResponsesOutputItemRole = {
-  Assistant: "assistant",
-} as const;
-export type ResponsesOutputItemRole = ClosedEnum<
-  typeof ResponsesOutputItemRole
->;
-
-export const ResponsesOutputItemTypeMessage = {
-  Message: "message",
-} as const;
-export type ResponsesOutputItemTypeMessage = ClosedEnum<
-  typeof ResponsesOutputItemTypeMessage
->;
-
 export const ResponsesOutputItemStatusInProgress = {
   InProgress: "in_progress",
 } as const;
@@ -154,28 +105,28 @@ export type ResponsesOutputItemStatusUnion =
   | ResponsesOutputItemStatusIncomplete
   | ResponsesOutputItemStatusInProgress;
 
-export type ResponsesOutputItemContent = OutputTextContent | RefusalContent;
-
-export type ResponsesOutputItemMessage = {
-  id: string;
-  role: ResponsesOutputItemRole;
-  type: ResponsesOutputItemTypeMessage;
-  status:
+export type ResponsesOutputItemFunctionCall = {
+  type: ResponsesOutputItemTypeFunctionCall;
+  id?: string | undefined;
+  name: string;
+  arguments: string;
+  callId: string;
+  status?:
     | ResponsesOutputItemStatusCompleted
     | ResponsesOutputItemStatusIncomplete
-    | ResponsesOutputItemStatusInProgress;
-  content: Array<OutputTextContent | RefusalContent>;
+    | ResponsesOutputItemStatusInProgress
+    | undefined;
 };
 
 /**
  * An output item from the response
  */
 export type ResponsesOutputItem =
-  | ResponsesOutputItemMessage
+  | OpenResponsesOutputMessage
   | ResponsesOutputItemFunctionCall
   | ResponsesOutputItemFileSearchCall
   | ResponsesOutputItemImageGenerationCall
-  | ResponsesOutputItemReasoning
+  | OpenResponsesOutputItemReasoning
   | ResponsesOutputItemWebSearchCall;
 
 /** @internal */
@@ -469,221 +420,6 @@ export namespace ResponsesOutputItemTypeFunctionCall$ {
     ResponsesOutputItemTypeFunctionCall$outboundSchema;
 }
 
-/** @internal */
-export const ResponsesOutputItemFunctionCall$inboundSchema: z.ZodType<
-  ResponsesOutputItemFunctionCall,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  type: ResponsesOutputItemTypeFunctionCall$inboundSchema,
-  id: z.string().optional(),
-  name: z.string(),
-  arguments: z.string(),
-  call_id: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    "call_id": "callId",
-  });
-});
-
-/** @internal */
-export type ResponsesOutputItemFunctionCall$Outbound = {
-  type: string;
-  id?: string | undefined;
-  name: string;
-  arguments: string;
-  call_id: string;
-};
-
-/** @internal */
-export const ResponsesOutputItemFunctionCall$outboundSchema: z.ZodType<
-  ResponsesOutputItemFunctionCall$Outbound,
-  z.ZodTypeDef,
-  ResponsesOutputItemFunctionCall
-> = z.object({
-  type: ResponsesOutputItemTypeFunctionCall$outboundSchema,
-  id: z.string().optional(),
-  name: z.string(),
-  arguments: z.string(),
-  callId: z.string(),
-}).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 ResponsesOutputItemFunctionCall$ {
-  /** @deprecated use `ResponsesOutputItemFunctionCall$inboundSchema` instead. */
-  export const inboundSchema = ResponsesOutputItemFunctionCall$inboundSchema;
-  /** @deprecated use `ResponsesOutputItemFunctionCall$outboundSchema` instead. */
-  export const outboundSchema = ResponsesOutputItemFunctionCall$outboundSchema;
-  /** @deprecated use `ResponsesOutputItemFunctionCall$Outbound` instead. */
-  export type Outbound = ResponsesOutputItemFunctionCall$Outbound;
-}
-
-export function responsesOutputItemFunctionCallToJSON(
-  responsesOutputItemFunctionCall: ResponsesOutputItemFunctionCall,
-): string {
-  return JSON.stringify(
-    ResponsesOutputItemFunctionCall$outboundSchema.parse(
-      responsesOutputItemFunctionCall,
-    ),
-  );
-}
-
-export function responsesOutputItemFunctionCallFromJSON(
-  jsonString: string,
-): SafeParseResult<ResponsesOutputItemFunctionCall, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ResponsesOutputItemFunctionCall$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ResponsesOutputItemFunctionCall' from JSON`,
-  );
-}
-
-/** @internal */
-export const ResponsesOutputItemTypeReasoning$inboundSchema: z.ZodNativeEnum<
-  typeof ResponsesOutputItemTypeReasoning
-> = z.nativeEnum(ResponsesOutputItemTypeReasoning);
-
-/** @internal */
-export const ResponsesOutputItemTypeReasoning$outboundSchema: z.ZodNativeEnum<
-  typeof ResponsesOutputItemTypeReasoning
-> = ResponsesOutputItemTypeReasoning$inboundSchema;
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace ResponsesOutputItemTypeReasoning$ {
-  /** @deprecated use `ResponsesOutputItemTypeReasoning$inboundSchema` instead. */
-  export const inboundSchema = ResponsesOutputItemTypeReasoning$inboundSchema;
-  /** @deprecated use `ResponsesOutputItemTypeReasoning$outboundSchema` instead. */
-  export const outboundSchema = ResponsesOutputItemTypeReasoning$outboundSchema;
-}
-
-/** @internal */
-export const ResponsesOutputItemReasoning$inboundSchema: z.ZodType<
-  ResponsesOutputItemReasoning,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  type: ResponsesOutputItemTypeReasoning$inboundSchema,
-  id: z.string(),
-  content: z.array(ReasoningTextContent$inboundSchema).optional(),
-  summary: z.array(ReasoningSummaryText$inboundSchema),
-  encrypted_content: z.nullable(z.string()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "encrypted_content": "encryptedContent",
-  });
-});
-
-/** @internal */
-export type ResponsesOutputItemReasoning$Outbound = {
-  type: string;
-  id: string;
-  content?: Array<ReasoningTextContent$Outbound> | undefined;
-  summary: Array<ReasoningSummaryText$Outbound>;
-  encrypted_content?: string | null | undefined;
-};
-
-/** @internal */
-export const ResponsesOutputItemReasoning$outboundSchema: z.ZodType<
-  ResponsesOutputItemReasoning$Outbound,
-  z.ZodTypeDef,
-  ResponsesOutputItemReasoning
-> = z.object({
-  type: ResponsesOutputItemTypeReasoning$outboundSchema,
-  id: z.string(),
-  content: z.array(ReasoningTextContent$outboundSchema).optional(),
-  summary: z.array(ReasoningSummaryText$outboundSchema),
-  encryptedContent: z.nullable(z.string()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    encryptedContent: "encrypted_content",
-  });
-});
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace ResponsesOutputItemReasoning$ {
-  /** @deprecated use `ResponsesOutputItemReasoning$inboundSchema` instead. */
-  export const inboundSchema = ResponsesOutputItemReasoning$inboundSchema;
-  /** @deprecated use `ResponsesOutputItemReasoning$outboundSchema` instead. */
-  export const outboundSchema = ResponsesOutputItemReasoning$outboundSchema;
-  /** @deprecated use `ResponsesOutputItemReasoning$Outbound` instead. */
-  export type Outbound = ResponsesOutputItemReasoning$Outbound;
-}
-
-export function responsesOutputItemReasoningToJSON(
-  responsesOutputItemReasoning: ResponsesOutputItemReasoning,
-): string {
-  return JSON.stringify(
-    ResponsesOutputItemReasoning$outboundSchema.parse(
-      responsesOutputItemReasoning,
-    ),
-  );
-}
-
-export function responsesOutputItemReasoningFromJSON(
-  jsonString: string,
-): SafeParseResult<ResponsesOutputItemReasoning, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ResponsesOutputItemReasoning$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ResponsesOutputItemReasoning' from JSON`,
-  );
-}
-
-/** @internal */
-export const ResponsesOutputItemRole$inboundSchema: z.ZodNativeEnum<
-  typeof ResponsesOutputItemRole
-> = z.nativeEnum(ResponsesOutputItemRole);
-
-/** @internal */
-export const ResponsesOutputItemRole$outboundSchema: z.ZodNativeEnum<
-  typeof ResponsesOutputItemRole
-> = ResponsesOutputItemRole$inboundSchema;
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace ResponsesOutputItemRole$ {
-  /** @deprecated use `ResponsesOutputItemRole$inboundSchema` instead. */
-  export const inboundSchema = ResponsesOutputItemRole$inboundSchema;
-  /** @deprecated use `ResponsesOutputItemRole$outboundSchema` instead. */
-  export const outboundSchema = ResponsesOutputItemRole$outboundSchema;
-}
-
-/** @internal */
-export const ResponsesOutputItemTypeMessage$inboundSchema: z.ZodNativeEnum<
-  typeof ResponsesOutputItemTypeMessage
-> = z.nativeEnum(ResponsesOutputItemTypeMessage);
-
-/** @internal */
-export const ResponsesOutputItemTypeMessage$outboundSchema: z.ZodNativeEnum<
-  typeof ResponsesOutputItemTypeMessage
-> = ResponsesOutputItemTypeMessage$inboundSchema;
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace ResponsesOutputItemTypeMessage$ {
-  /** @deprecated use `ResponsesOutputItemTypeMessage$inboundSchema` instead. */
-  export const inboundSchema = ResponsesOutputItemTypeMessage$inboundSchema;
-  /** @deprecated use `ResponsesOutputItemTypeMessage$outboundSchema` instead. */
-  export const outboundSchema = ResponsesOutputItemTypeMessage$outboundSchema;
-}
-
 /** @internal */
 export const ResponsesOutputItemStatusInProgress$inboundSchema: z.ZodNativeEnum<
   typeof ResponsesOutputItemStatusInProgress
@@ -811,130 +547,89 @@ export function responsesOutputItemStatusUnionFromJSON(
 }
 
 /** @internal */
-export const ResponsesOutputItemContent$inboundSchema: z.ZodType<
-  ResponsesOutputItemContent,
-  z.ZodTypeDef,
-  unknown
-> = z.union([OutputTextContent$inboundSchema, RefusalContent$inboundSchema]);
-
-/** @internal */
-export type ResponsesOutputItemContent$Outbound =
-  | OutputTextContent$Outbound
-  | RefusalContent$Outbound;
-
-/** @internal */
-export const ResponsesOutputItemContent$outboundSchema: z.ZodType<
-  ResponsesOutputItemContent$Outbound,
-  z.ZodTypeDef,
-  ResponsesOutputItemContent
-> = z.union([OutputTextContent$outboundSchema, RefusalContent$outboundSchema]);
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace ResponsesOutputItemContent$ {
-  /** @deprecated use `ResponsesOutputItemContent$inboundSchema` instead. */
-  export const inboundSchema = ResponsesOutputItemContent$inboundSchema;
-  /** @deprecated use `ResponsesOutputItemContent$outboundSchema` instead. */
-  export const outboundSchema = ResponsesOutputItemContent$outboundSchema;
-  /** @deprecated use `ResponsesOutputItemContent$Outbound` instead. */
-  export type Outbound = ResponsesOutputItemContent$Outbound;
-}
-
-export function responsesOutputItemContentToJSON(
-  responsesOutputItemContent: ResponsesOutputItemContent,
-): string {
-  return JSON.stringify(
-    ResponsesOutputItemContent$outboundSchema.parse(responsesOutputItemContent),
-  );
-}
-
-export function responsesOutputItemContentFromJSON(
-  jsonString: string,
-): SafeParseResult<ResponsesOutputItemContent, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ResponsesOutputItemContent$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ResponsesOutputItemContent' from JSON`,
-  );
-}
-
-/** @internal */
-export const ResponsesOutputItemMessage$inboundSchema: z.ZodType<
-  ResponsesOutputItemMessage,
+export const ResponsesOutputItemFunctionCall$inboundSchema: z.ZodType<
+  ResponsesOutputItemFunctionCall,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.string(),
-  role: ResponsesOutputItemRole$inboundSchema,
-  type: ResponsesOutputItemTypeMessage$inboundSchema,
+  type: ResponsesOutputItemTypeFunctionCall$inboundSchema,
+  id: z.string().optional(),
+  name: z.string(),
+  arguments: z.string(),
+  call_id: z.string(),
   status: z.union([
     ResponsesOutputItemStatusCompleted$inboundSchema,
     ResponsesOutputItemStatusIncomplete$inboundSchema,
     ResponsesOutputItemStatusInProgress$inboundSchema,
-  ]),
-  content: z.array(
-    z.union([OutputTextContent$inboundSchema, RefusalContent$inboundSchema]),
-  ),
+  ]).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "call_id": "callId",
+  });
 });
 
 /** @internal */
-export type ResponsesOutputItemMessage$Outbound = {
-  id: string;
-  role: string;
+export type ResponsesOutputItemFunctionCall$Outbound = {
   type: string;
-  status: string | string | string;
-  content: Array<OutputTextContent$Outbound | RefusalContent$Outbound>;
+  id?: string | undefined;
+  name: string;
+  arguments: string;
+  call_id: string;
+  status?: string | string | string | undefined;
 };
 
 /** @internal */
-export const ResponsesOutputItemMessage$outboundSchema: z.ZodType<
-  ResponsesOutputItemMessage$Outbound,
+export const ResponsesOutputItemFunctionCall$outboundSchema: z.ZodType<
+  ResponsesOutputItemFunctionCall$Outbound,
   z.ZodTypeDef,
-  ResponsesOutputItemMessage
+  ResponsesOutputItemFunctionCall
 > = z.object({
-  id: z.string(),
-  role: ResponsesOutputItemRole$outboundSchema,
-  type: ResponsesOutputItemTypeMessage$outboundSchema,
+  type: ResponsesOutputItemTypeFunctionCall$outboundSchema,
+  id: z.string().optional(),
+  name: z.string(),
+  arguments: z.string(),
+  callId: z.string(),
   status: z.union([
     ResponsesOutputItemStatusCompleted$outboundSchema,
     ResponsesOutputItemStatusIncomplete$outboundSchema,
     ResponsesOutputItemStatusInProgress$outboundSchema,
-  ]),
-  content: z.array(
-    z.union([OutputTextContent$outboundSchema, RefusalContent$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 ResponsesOutputItemMessage$ {
-  /** @deprecated use `ResponsesOutputItemMessage$inboundSchema` instead. */
-  export const inboundSchema = ResponsesOutputItemMessage$inboundSchema;
-  /** @deprecated use `ResponsesOutputItemMessage$outboundSchema` instead. */
-  export const outboundSchema = ResponsesOutputItemMessage$outboundSchema;
-  /** @deprecated use `ResponsesOutputItemMessage$Outbound` instead. */
-  export type Outbound = ResponsesOutputItemMessage$Outbound;
+export namespace ResponsesOutputItemFunctionCall$ {
+  /** @deprecated use `ResponsesOutputItemFunctionCall$inboundSchema` instead. */
+  export const inboundSchema = ResponsesOutputItemFunctionCall$inboundSchema;
+  /** @deprecated use `ResponsesOutputItemFunctionCall$outboundSchema` instead. */
+  export const outboundSchema = ResponsesOutputItemFunctionCall$outboundSchema;
+  /** @deprecated use `ResponsesOutputItemFunctionCall$Outbound` instead. */
+  export type Outbound = ResponsesOutputItemFunctionCall$Outbound;
 }
 
-export function responsesOutputItemMessageToJSON(
-  responsesOutputItemMessage: ResponsesOutputItemMessage,
+export function responsesOutputItemFunctionCallToJSON(
+  responsesOutputItemFunctionCall: ResponsesOutputItemFunctionCall,
 ): string {
   return JSON.stringify(
-    ResponsesOutputItemMessage$outboundSchema.parse(responsesOutputItemMessage),
+    ResponsesOutputItemFunctionCall$outboundSchema.parse(
+      responsesOutputItemFunctionCall,
+    ),
   );
 }
 
-export function responsesOutputItemMessageFromJSON(
+export function responsesOutputItemFunctionCallFromJSON(
   jsonString: string,
-): SafeParseResult<ResponsesOutputItemMessage, SDKValidationError> {
+): SafeParseResult<ResponsesOutputItemFunctionCall, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ResponsesOutputItemMessage$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ResponsesOutputItemMessage' from JSON`,
+    (x) => ResponsesOutputItemFunctionCall$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponsesOutputItemFunctionCall' from JSON`,
   );
 }
 
@@ -944,21 +639,21 @@ export const ResponsesOutputItem$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.lazy(() => ResponsesOutputItemMessage$inboundSchema),
+  OpenResponsesOutputMessage$inboundSchema,
   z.lazy(() => ResponsesOutputItemFunctionCall$inboundSchema),
   z.lazy(() => ResponsesOutputItemFileSearchCall$inboundSchema),
   z.lazy(() => ResponsesOutputItemImageGenerationCall$inboundSchema),
-  z.lazy(() => ResponsesOutputItemReasoning$inboundSchema),
+  OpenResponsesOutputItemReasoning$inboundSchema,
   z.lazy(() => ResponsesOutputItemWebSearchCall$inboundSchema),
 ]);
 
 /** @internal */
 export type ResponsesOutputItem$Outbound =
-  | ResponsesOutputItemMessage$Outbound
+  | OpenResponsesOutputMessage$Outbound
   | ResponsesOutputItemFunctionCall$Outbound
   | ResponsesOutputItemFileSearchCall$Outbound
   | ResponsesOutputItemImageGenerationCall$Outbound
-  | ResponsesOutputItemReasoning$Outbound
+  | OpenResponsesOutputItemReasoning$Outbound
   | ResponsesOutputItemWebSearchCall$Outbound;
 
 /** @internal */
@@ -967,11 +662,11 @@ export const ResponsesOutputItem$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ResponsesOutputItem
 > = z.union([
-  z.lazy(() => ResponsesOutputItemMessage$outboundSchema),
+  OpenResponsesOutputMessage$outboundSchema,
   z.lazy(() => ResponsesOutputItemFunctionCall$outboundSchema),
   z.lazy(() => ResponsesOutputItemFileSearchCall$outboundSchema),
   z.lazy(() => ResponsesOutputItemImageGenerationCall$outboundSchema),
-  z.lazy(() => ResponsesOutputItemReasoning$outboundSchema),
+  OpenResponsesOutputItemReasoning$outboundSchema,
   z.lazy(() => ResponsesOutputItemWebSearchCall$outboundSchema),
 ]);
 

package/src/models/responsetextconfig.ts

@@ -0,0 +1,128 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../lib/schemas.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import {
+  ResponseFormatTextConfig,
+  ResponseFormatTextConfig$inboundSchema,
+  ResponseFormatTextConfig$Outbound,
+  ResponseFormatTextConfig$outboundSchema,
+} from "./responseformattextconfig.js";
+
+export const ResponseTextConfigVerbosity = {
+  High: "high",
+  Low: "low",
+  Medium: "medium",
+} as const;
+export type ResponseTextConfigVerbosity = OpenEnum<
+  typeof ResponseTextConfigVerbosity
+>;
+
+/**
+ * Text output configuration including format and verbosity
+ */
+export type ResponseTextConfig = {
+  /**
+   * Text response format configuration
+   */
+  format?: ResponseFormatTextConfig | undefined;
+  verbosity?: ResponseTextConfigVerbosity | null | undefined;
+};
+
+/** @internal */
+export const ResponseTextConfigVerbosity$inboundSchema: z.ZodType<
+  ResponseTextConfigVerbosity,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponseTextConfigVerbosity),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
+
+/** @internal */
+export const ResponseTextConfigVerbosity$outboundSchema: z.ZodType<
+  ResponseTextConfigVerbosity,
+  z.ZodTypeDef,
+  ResponseTextConfigVerbosity
+> = z.union([
+  z.nativeEnum(ResponseTextConfigVerbosity),
+  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 ResponseTextConfigVerbosity$ {
+  /** @deprecated use `ResponseTextConfigVerbosity$inboundSchema` instead. */
+  export const inboundSchema = ResponseTextConfigVerbosity$inboundSchema;
+  /** @deprecated use `ResponseTextConfigVerbosity$outboundSchema` instead. */
+  export const outboundSchema = ResponseTextConfigVerbosity$outboundSchema;
+}
+
+/** @internal */
+export const ResponseTextConfig$inboundSchema: z.ZodType<
+  ResponseTextConfig,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  format: ResponseFormatTextConfig$inboundSchema.optional(),
+  verbosity: z.nullable(ResponseTextConfigVerbosity$inboundSchema).optional(),
+});
+
+/** @internal */
+export type ResponseTextConfig$Outbound = {
+  format?: ResponseFormatTextConfig$Outbound | undefined;
+  verbosity?: string | null | undefined;
+};
+
+/** @internal */
+export const ResponseTextConfig$outboundSchema: z.ZodType<
+  ResponseTextConfig$Outbound,
+  z.ZodTypeDef,
+  ResponseTextConfig
+> = z.object({
+  format: ResponseFormatTextConfig$outboundSchema.optional(),
+  verbosity: z.nullable(ResponseTextConfigVerbosity$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 ResponseTextConfig$ {
+  /** @deprecated use `ResponseTextConfig$inboundSchema` instead. */
+  export const inboundSchema = ResponseTextConfig$inboundSchema;
+  /** @deprecated use `ResponseTextConfig$outboundSchema` instead. */
+  export const outboundSchema = ResponseTextConfig$outboundSchema;
+  /** @deprecated use `ResponseTextConfig$Outbound` instead. */
+  export type Outbound = ResponseTextConfig$Outbound;
+}
+
+export function responseTextConfigToJSON(
+  responseTextConfig: ResponseTextConfig,
+): string {
+  return JSON.stringify(
+    ResponseTextConfig$outboundSchema.parse(responseTextConfig),
+  );
+}
+
+export function responseTextConfigFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseTextConfig, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseTextConfig$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseTextConfig' from JSON`,
+  );
+}