@openrouter/sdk 0.0.0-beta.32 → 0.0.0-beta.37

package/src/models/responsereasoningconfig.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
@@ -29,6 +30,8 @@ export type ResponseReasoningConfigEffort = ClosedEnum<
 export type ResponseReasoningConfig = {
   effort?: ResponseReasoningConfigEffort | null | undefined;
   summary?: ResponseReasoningSummaryMode | null | undefined;
+  maxTokens?: number | null | undefined;
+  enabled?: boolean | null | undefined;
 };
 
 /** @internal */
@@ -60,12 +63,20 @@ export const ResponseReasoningConfig$inboundSchema: z.ZodType<
 > = z.object({
   effort: z.nullable(ResponseReasoningConfigEffort$inboundSchema).optional(),
   summary: z.nullable(ResponseReasoningSummaryMode$inboundSchema).optional(),
+  max_tokens: z.nullable(z.number()).optional(),
+  enabled: z.nullable(z.boolean()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "max_tokens": "maxTokens",
+  });
 });
 
 /** @internal */
 export type ResponseReasoningConfig$Outbound = {
   effort?: string | null | undefined;
   summary?: string | null | undefined;
+  max_tokens?: number | null | undefined;
+  enabled?: boolean | null | undefined;
 };
 
 /** @internal */
@@ -76,6 +87,12 @@ export const ResponseReasoningConfig$outboundSchema: z.ZodType<
 > = z.object({
   effort: z.nullable(ResponseReasoningConfigEffort$outboundSchema).optional(),
   summary: z.nullable(ResponseReasoningSummaryMode$outboundSchema).optional(),
+  maxTokens: z.nullable(z.number()).optional(),
+  enabled: z.nullable(z.boolean()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    maxTokens: "max_tokens",
+  });
 });
 
 /**

package/src/models/responsesnonstreamingresponse.ts

@@ -57,11 +57,11 @@ import {
   Tool$outboundSchema,
 } from "./tool.js";
 import {
-  ToolChoice,
-  ToolChoice$inboundSchema,
-  ToolChoice$Outbound,
-  ToolChoice$outboundSchema,
-} from "./toolchoice.js";
+  ToolChoiceUnion,
+  ToolChoiceUnion$inboundSchema,
+  ToolChoiceUnion$Outbound,
+  ToolChoiceUnion$outboundSchema,
+} from "./toolchoiceunion.js";
 
 export const ObjectT = {
   Response: "response",
@@ -96,24 +96,20 @@ export type ResponsesNonStreamingResponseError = {
 
 export type Instructions = string | Array<ResponseInputItem> | any;
 
-export const ResponsesNonStreamingResponseServiceTier = {
+export const ServiceTier = {
   Auto: "auto",
   Default: "default",
   Flex: "flex",
   Priority: "priority",
   Scale: "scale",
 } as const;
-export type ResponsesNonStreamingResponseServiceTier = ClosedEnum<
-  typeof ResponsesNonStreamingResponseServiceTier
->;
+export type ServiceTier = ClosedEnum<typeof ServiceTier>;
 
-export const ResponsesNonStreamingResponseTruncation = {
+export const Truncation = {
   Auto: "auto",
   Disabled: "disabled",
 } as const;
-export type ResponsesNonStreamingResponseTruncation = ClosedEnum<
-  typeof ResponsesNonStreamingResponseTruncation
->;
+export type Truncation = ClosedEnum<typeof Truncation>;
 
 /**
  * Non-streaming response from Responses API
@@ -152,7 +148,7 @@ export type ResponsesNonStreamingResponse = {
   /**
    * Tool choice configuration
    */
-  toolChoice: ToolChoice;
+  toolChoice: ToolChoiceUnion;
   parallelToolCalls: boolean;
   /**
    * Prompt configuration with variables
@@ -164,9 +160,9 @@ export type ResponsesNonStreamingResponse = {
    * Reasoning configuration for Responses API
    */
   reasoning?: ResponseReasoningConfig | null | undefined;
-  serviceTier?: ResponsesNonStreamingResponseServiceTier | null | undefined;
+  serviceTier?: ServiceTier | null | undefined;
   store?: boolean | undefined;
-  truncation?: ResponsesNonStreamingResponseTruncation | null | undefined;
+  truncation?: Truncation | null | undefined;
   /**
    * Text configuration for Responses API
    */
@@ -346,49 +342,41 @@ export function instructionsFromJSON(
 }
 
 /** @internal */
-export const ResponsesNonStreamingResponseServiceTier$inboundSchema:
-  z.ZodNativeEnum<typeof ResponsesNonStreamingResponseServiceTier> = z
-    .nativeEnum(ResponsesNonStreamingResponseServiceTier);
+export const ServiceTier$inboundSchema: z.ZodNativeEnum<typeof ServiceTier> = z
+  .nativeEnum(ServiceTier);
 
 /** @internal */
-export const ResponsesNonStreamingResponseServiceTier$outboundSchema:
-  z.ZodNativeEnum<typeof ResponsesNonStreamingResponseServiceTier> =
-    ResponsesNonStreamingResponseServiceTier$inboundSchema;
+export const ServiceTier$outboundSchema: z.ZodNativeEnum<typeof ServiceTier> =
+  ServiceTier$inboundSchema;
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace ResponsesNonStreamingResponseServiceTier$ {
-  /** @deprecated use `ResponsesNonStreamingResponseServiceTier$inboundSchema` instead. */
-  export const inboundSchema =
-    ResponsesNonStreamingResponseServiceTier$inboundSchema;
-  /** @deprecated use `ResponsesNonStreamingResponseServiceTier$outboundSchema` instead. */
-  export const outboundSchema =
-    ResponsesNonStreamingResponseServiceTier$outboundSchema;
+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 ResponsesNonStreamingResponseTruncation$inboundSchema:
-  z.ZodNativeEnum<typeof ResponsesNonStreamingResponseTruncation> = z
-    .nativeEnum(ResponsesNonStreamingResponseTruncation);
+export const Truncation$inboundSchema: z.ZodNativeEnum<typeof Truncation> = z
+  .nativeEnum(Truncation);
 
 /** @internal */
-export const ResponsesNonStreamingResponseTruncation$outboundSchema:
-  z.ZodNativeEnum<typeof ResponsesNonStreamingResponseTruncation> =
-    ResponsesNonStreamingResponseTruncation$inboundSchema;
+export const Truncation$outboundSchema: z.ZodNativeEnum<typeof Truncation> =
+  Truncation$inboundSchema;
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace ResponsesNonStreamingResponseTruncation$ {
-  /** @deprecated use `ResponsesNonStreamingResponseTruncation$inboundSchema` instead. */
-  export const inboundSchema =
-    ResponsesNonStreamingResponseTruncation$inboundSchema;
-  /** @deprecated use `ResponsesNonStreamingResponseTruncation$outboundSchema` instead. */
-  export const outboundSchema =
-    ResponsesNonStreamingResponseTruncation$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 */
@@ -422,18 +410,15 @@ export const ResponsesNonStreamingResponse$inboundSchema: z.ZodType<
   ).optional(),
   metadata: z.nullable(z.record(z.string())),
   tools: z.array(Tool$inboundSchema),
-  tool_choice: ToolChoice$inboundSchema,
+  tool_choice: ToolChoiceUnion$inboundSchema,
   parallel_tool_calls: z.boolean(),
   prompt: z.nullable(ResponsePrompt$inboundSchema).optional(),
   background: z.nullable(z.boolean()).optional(),
   previous_response_id: z.nullable(z.string()).optional(),
   reasoning: z.nullable(ResponseReasoningConfig$inboundSchema).optional(),
-  service_tier: z.nullable(
-    ResponsesNonStreamingResponseServiceTier$inboundSchema,
-  ).optional(),
+  service_tier: z.nullable(ServiceTier$inboundSchema).optional(),
   store: z.boolean().optional(),
-  truncation: z.nullable(ResponsesNonStreamingResponseTruncation$inboundSchema)
-    .optional(),
+  truncation: z.nullable(Truncation$inboundSchema).optional(),
   text: ResponseTextConfig$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -481,7 +466,7 @@ export type ResponsesNonStreamingResponse$Outbound = {
     | undefined;
   metadata: { [k: string]: string } | null;
   tools: Array<Tool$Outbound>;
-  tool_choice: ToolChoice$Outbound;
+  tool_choice: ToolChoiceUnion$Outbound;
   parallel_tool_calls: boolean;
   prompt?: ResponsePrompt$Outbound | null | undefined;
   background?: boolean | null | undefined;
@@ -524,18 +509,15 @@ export const ResponsesNonStreamingResponse$outboundSchema: z.ZodType<
   ).optional(),
   metadata: z.nullable(z.record(z.string())),
   tools: z.array(Tool$outboundSchema),
-  toolChoice: ToolChoice$outboundSchema,
+  toolChoice: ToolChoiceUnion$outboundSchema,
   parallelToolCalls: z.boolean(),
   prompt: z.nullable(ResponsePrompt$outboundSchema).optional(),
   background: z.nullable(z.boolean()).optional(),
   previousResponseId: z.nullable(z.string()).optional(),
   reasoning: z.nullable(ResponseReasoningConfig$outboundSchema).optional(),
-  serviceTier: z.nullable(
-    ResponsesNonStreamingResponseServiceTier$outboundSchema,
-  ).optional(),
+  serviceTier: z.nullable(ServiceTier$outboundSchema).optional(),
   store: z.boolean().optional(),
-  truncation: z.nullable(ResponsesNonStreamingResponseTruncation$outboundSchema)
-    .optional(),
+  truncation: z.nullable(Truncation$outboundSchema).optional(),
   text: ResponseTextConfig$outboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {

package/src/models/responsesusage.ts

@@ -20,6 +20,12 @@ import {
   ResponsesOutputTokensDetails$outboundSchema,
 } from "./responsesoutputtokensdetails.js";
 
+export type CostDetails = {
+  upstreamInferenceCost?: number | null | undefined;
+  upstreamInferenceInputCost: number;
+  upstreamInferenceOutputCost: number;
+};
+
 /**
  * Token usage statistics for Responses API
  */
@@ -35,8 +41,85 @@ export type ResponsesUsage = {
    */
   outputTokensDetails: ResponsesOutputTokensDetails;
   totalTokens: number;
+  /**
+   * Cost of the completion
+   */
+  cost?: number | null | undefined;
+  /**
+   * Whether a request was made using a Bring Your Own Key configuration
+   */
+  isByok?: boolean | undefined;
+  costDetails?: CostDetails | undefined;
+};
+
+/** @internal */
+export const CostDetails$inboundSchema: z.ZodType<
+  CostDetails,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  upstream_inference_cost: z.nullable(z.number()).optional(),
+  upstream_inference_input_cost: z.number(),
+  upstream_inference_output_cost: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    "upstream_inference_cost": "upstreamInferenceCost",
+    "upstream_inference_input_cost": "upstreamInferenceInputCost",
+    "upstream_inference_output_cost": "upstreamInferenceOutputCost",
+  });
+});
+
+/** @internal */
+export type CostDetails$Outbound = {
+  upstream_inference_cost?: number | null | undefined;
+  upstream_inference_input_cost: number;
+  upstream_inference_output_cost: number;
 };
 
+/** @internal */
+export const CostDetails$outboundSchema: z.ZodType<
+  CostDetails$Outbound,
+  z.ZodTypeDef,
+  CostDetails
+> = z.object({
+  upstreamInferenceCost: z.nullable(z.number()).optional(),
+  upstreamInferenceInputCost: z.number(),
+  upstreamInferenceOutputCost: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    upstreamInferenceCost: "upstream_inference_cost",
+    upstreamInferenceInputCost: "upstream_inference_input_cost",
+    upstreamInferenceOutputCost: "upstream_inference_output_cost",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace CostDetails$ {
+  /** @deprecated use `CostDetails$inboundSchema` instead. */
+  export const inboundSchema = CostDetails$inboundSchema;
+  /** @deprecated use `CostDetails$outboundSchema` instead. */
+  export const outboundSchema = CostDetails$outboundSchema;
+  /** @deprecated use `CostDetails$Outbound` instead. */
+  export type Outbound = CostDetails$Outbound;
+}
+
+export function costDetailsToJSON(costDetails: CostDetails): string {
+  return JSON.stringify(CostDetails$outboundSchema.parse(costDetails));
+}
+
+export function costDetailsFromJSON(
+  jsonString: string,
+): SafeParseResult<CostDetails, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CostDetails$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CostDetails' from JSON`,
+  );
+}
+
 /** @internal */
 export const ResponsesUsage$inboundSchema: z.ZodType<
   ResponsesUsage,
@@ -48,6 +131,9 @@ export const ResponsesUsage$inboundSchema: z.ZodType<
   output_tokens: z.number(),
   output_tokens_details: ResponsesOutputTokensDetails$inboundSchema,
   total_tokens: z.number(),
+  cost: z.nullable(z.number()).optional(),
+  is_byok: z.boolean().optional(),
+  cost_details: z.lazy(() => CostDetails$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "input_tokens": "inputTokens",
@@ -55,6 +141,8 @@ export const ResponsesUsage$inboundSchema: z.ZodType<
     "output_tokens": "outputTokens",
     "output_tokens_details": "outputTokensDetails",
     "total_tokens": "totalTokens",
+    "is_byok": "isByok",
+    "cost_details": "costDetails",
   });
 });
 
@@ -65,6 +153,9 @@ export type ResponsesUsage$Outbound = {
   output_tokens: number;
   output_tokens_details: ResponsesOutputTokensDetails$Outbound;
   total_tokens: number;
+  cost?: number | null | undefined;
+  is_byok?: boolean | undefined;
+  cost_details?: CostDetails$Outbound | undefined;
 };
 
 /** @internal */
@@ -78,6 +169,9 @@ export const ResponsesUsage$outboundSchema: z.ZodType<
   outputTokens: z.number(),
   outputTokensDetails: ResponsesOutputTokensDetails$outboundSchema,
   totalTokens: z.number(),
+  cost: z.nullable(z.number()).optional(),
+  isByok: z.boolean().optional(),
+  costDetails: z.lazy(() => CostDetails$outboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     inputTokens: "input_tokens",
@@ -85,6 +179,8 @@ export const ResponsesUsage$outboundSchema: z.ZodType<
     outputTokens: "output_tokens",
     outputTokensDetails: "output_tokens_details",
     totalTokens: "total_tokens",
+    isByok: "is_byok",
+    costDetails: "cost_details",
   });
 });
 

package/src/models/{toolchoice.ts → toolchoiceunion.ts}

@@ -8,17 +8,31 @@ import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import {
-  ToolChoiceFunction,
-  ToolChoiceFunction$inboundSchema,
-  ToolChoiceFunction$Outbound,
-  ToolChoiceFunction$outboundSchema,
-} from "./toolchoicefunction.js";
-import {
-  ToolChoiceTypes,
-  ToolChoiceTypes$inboundSchema,
-  ToolChoiceTypes$Outbound,
-  ToolChoiceTypes$outboundSchema,
-} from "./toolchoicetypes.js";
+  ToolChoiceTypeUnion,
+  ToolChoiceTypeUnion$inboundSchema,
+  ToolChoiceTypeUnion$Outbound,
+  ToolChoiceTypeUnion$outboundSchema,
+} from "./toolchoicetypeunion.js";
+
+export const ToolChoiceType = {
+  Function: "function",
+} as const;
+export type ToolChoiceType = ClosedEnum<typeof ToolChoiceType>;
+
+/**
+ * Specific function tool choice
+ */
+export type ToolChoiceFunction = {
+  type: ToolChoiceType;
+  name: string;
+};
+
+/**
+ * Tool choice by type
+ */
+export type ToolChoice = {
+  type: ToolChoiceTypeUnion;
+};
 
 export const ToolChoiceRequired = {
   Required: "required",
@@ -38,13 +52,141 @@ export type ToolChoiceAuto = ClosedEnum<typeof ToolChoiceAuto>;
 /**
  * Tool choice configuration
  */
-export type ToolChoice =
+export type ToolChoiceUnion =
   | ToolChoiceFunction
-  | ToolChoiceTypes
+  | ToolChoice
   | ToolChoiceAuto
   | ToolChoiceNone
   | ToolChoiceRequired;
 
+/** @internal */
+export const ToolChoiceType$inboundSchema: z.ZodNativeEnum<
+  typeof ToolChoiceType
+> = z.nativeEnum(ToolChoiceType);
+
+/** @internal */
+export const ToolChoiceType$outboundSchema: z.ZodNativeEnum<
+  typeof ToolChoiceType
+> = ToolChoiceType$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ToolChoiceType$ {
+  /** @deprecated use `ToolChoiceType$inboundSchema` instead. */
+  export const inboundSchema = ToolChoiceType$inboundSchema;
+  /** @deprecated use `ToolChoiceType$outboundSchema` instead. */
+  export const outboundSchema = ToolChoiceType$outboundSchema;
+}
+
+/** @internal */
+export const ToolChoiceFunction$inboundSchema: z.ZodType<
+  ToolChoiceFunction,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: ToolChoiceType$inboundSchema,
+  name: z.string(),
+});
+
+/** @internal */
+export type ToolChoiceFunction$Outbound = {
+  type: string;
+  name: string;
+};
+
+/** @internal */
+export const ToolChoiceFunction$outboundSchema: z.ZodType<
+  ToolChoiceFunction$Outbound,
+  z.ZodTypeDef,
+  ToolChoiceFunction
+> = z.object({
+  type: ToolChoiceType$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 ToolChoiceFunction$ {
+  /** @deprecated use `ToolChoiceFunction$inboundSchema` instead. */
+  export const inboundSchema = ToolChoiceFunction$inboundSchema;
+  /** @deprecated use `ToolChoiceFunction$outboundSchema` instead. */
+  export const outboundSchema = ToolChoiceFunction$outboundSchema;
+  /** @deprecated use `ToolChoiceFunction$Outbound` instead. */
+  export type Outbound = ToolChoiceFunction$Outbound;
+}
+
+export function toolChoiceFunctionToJSON(
+  toolChoiceFunction: ToolChoiceFunction,
+): string {
+  return JSON.stringify(
+    ToolChoiceFunction$outboundSchema.parse(toolChoiceFunction),
+  );
+}
+
+export function toolChoiceFunctionFromJSON(
+  jsonString: string,
+): SafeParseResult<ToolChoiceFunction, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ToolChoiceFunction$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolChoiceFunction' from JSON`,
+  );
+}
+
+/** @internal */
+export const ToolChoice$inboundSchema: z.ZodType<
+  ToolChoice,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: ToolChoiceTypeUnion$inboundSchema,
+});
+
+/** @internal */
+export type ToolChoice$Outbound = {
+  type: ToolChoiceTypeUnion$Outbound;
+};
+
+/** @internal */
+export const ToolChoice$outboundSchema: z.ZodType<
+  ToolChoice$Outbound,
+  z.ZodTypeDef,
+  ToolChoice
+> = z.object({
+  type: ToolChoiceTypeUnion$outboundSchema,
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ToolChoice$ {
+  /** @deprecated use `ToolChoice$inboundSchema` instead. */
+  export const inboundSchema = ToolChoice$inboundSchema;
+  /** @deprecated use `ToolChoice$outboundSchema` instead. */
+  export const outboundSchema = ToolChoice$outboundSchema;
+  /** @deprecated use `ToolChoice$Outbound` instead. */
+  export type Outbound = ToolChoice$Outbound;
+}
+
+export function toolChoiceToJSON(toolChoice: ToolChoice): string {
+  return JSON.stringify(ToolChoice$outboundSchema.parse(toolChoice));
+}
+
+export function toolChoiceFromJSON(
+  jsonString: string,
+): SafeParseResult<ToolChoice, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ToolChoice$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolChoice' from JSON`,
+  );
+}
+
 /** @internal */
 export const ToolChoiceRequired$inboundSchema: z.ZodNativeEnum<
   typeof ToolChoiceRequired
@@ -109,34 +251,34 @@ export namespace ToolChoiceAuto$ {
 }
 
 /** @internal */
-export const ToolChoice$inboundSchema: z.ZodType<
-  ToolChoice,
+export const ToolChoiceUnion$inboundSchema: z.ZodType<
+  ToolChoiceUnion,
   z.ZodTypeDef,
   unknown
 > = z.union([
-  ToolChoiceFunction$inboundSchema,
-  ToolChoiceTypes$inboundSchema,
+  z.lazy(() => ToolChoiceFunction$inboundSchema),
+  z.lazy(() => ToolChoice$inboundSchema),
   ToolChoiceAuto$inboundSchema,
   ToolChoiceNone$inboundSchema,
   ToolChoiceRequired$inboundSchema,
 ]);
 
 /** @internal */
-export type ToolChoice$Outbound =
+export type ToolChoiceUnion$Outbound =
   | ToolChoiceFunction$Outbound
-  | ToolChoiceTypes$Outbound
+  | ToolChoice$Outbound
   | string
   | string
   | string;
 
 /** @internal */
-export const ToolChoice$outboundSchema: z.ZodType<
-  ToolChoice$Outbound,
+export const ToolChoiceUnion$outboundSchema: z.ZodType<
+  ToolChoiceUnion$Outbound,
   z.ZodTypeDef,
-  ToolChoice
+  ToolChoiceUnion
 > = z.union([
-  ToolChoiceFunction$outboundSchema,
-  ToolChoiceTypes$outboundSchema,
+  z.lazy(() => ToolChoiceFunction$outboundSchema),
+  z.lazy(() => ToolChoice$outboundSchema),
   ToolChoiceAuto$outboundSchema,
   ToolChoiceNone$outboundSchema,
   ToolChoiceRequired$outboundSchema,
@@ -146,25 +288,27 @@ export const ToolChoice$outboundSchema: z.ZodType<
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace ToolChoice$ {
-  /** @deprecated use `ToolChoice$inboundSchema` instead. */
-  export const inboundSchema = ToolChoice$inboundSchema;
-  /** @deprecated use `ToolChoice$outboundSchema` instead. */
-  export const outboundSchema = ToolChoice$outboundSchema;
-  /** @deprecated use `ToolChoice$Outbound` instead. */
-  export type Outbound = ToolChoice$Outbound;
+export namespace ToolChoiceUnion$ {
+  /** @deprecated use `ToolChoiceUnion$inboundSchema` instead. */
+  export const inboundSchema = ToolChoiceUnion$inboundSchema;
+  /** @deprecated use `ToolChoiceUnion$outboundSchema` instead. */
+  export const outboundSchema = ToolChoiceUnion$outboundSchema;
+  /** @deprecated use `ToolChoiceUnion$Outbound` instead. */
+  export type Outbound = ToolChoiceUnion$Outbound;
 }
 
-export function toolChoiceToJSON(toolChoice: ToolChoice): string {
-  return JSON.stringify(ToolChoice$outboundSchema.parse(toolChoice));
+export function toolChoiceUnionToJSON(
+  toolChoiceUnion: ToolChoiceUnion,
+): string {
+  return JSON.stringify(ToolChoiceUnion$outboundSchema.parse(toolChoiceUnion));
 }
 
-export function toolChoiceFromJSON(
+export function toolChoiceUnionFromJSON(
   jsonString: string,
-): SafeParseResult<ToolChoice, SDKValidationError> {
+): SafeParseResult<ToolChoiceUnion, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ToolChoice$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ToolChoice' from JSON`,
+    (x) => ToolChoiceUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolChoiceUnion' from JSON`,
   );
 }