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

package/src/models/chatgenerationparams.ts

@@ -5,7 +5,11 @@
 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 {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import {
   ChatStreamOptions,
@@ -20,6 +24,23 @@ import {
   Message$Outbound,
   Message$outboundSchema,
 } from "./message.js";
+import {
+  ReasoningSummaryVerbosity,
+  ReasoningSummaryVerbosity$inboundSchema,
+  ReasoningSummaryVerbosity$outboundSchema,
+} from "./reasoningsummaryverbosity.js";
+import {
+  ResponseFormatJSONSchema,
+  ResponseFormatJSONSchema$inboundSchema,
+  ResponseFormatJSONSchema$Outbound,
+  ResponseFormatJSONSchema$outboundSchema,
+} from "./responseformatjsonschema.js";
+import {
+  ResponseFormatTextGrammar,
+  ResponseFormatTextGrammar$inboundSchema,
+  ResponseFormatTextGrammar$Outbound,
+  ResponseFormatTextGrammar$outboundSchema,
+} from "./responseformattextgrammar.js";
 import {
   Tool,
   Tool$inboundSchema,
@@ -27,71 +48,41 @@ import {
   Tool$outboundSchema,
 } from "./tool.js";
 
-export const Effort = {
+export const ChatGenerationParamsEffort = {
   Minimal: "minimal",
   Low: "low",
   Medium: "medium",
   High: "high",
 } as const;
-export type Effort = ClosedEnum<typeof Effort>;
-
-export const GenerateSummary = {
-  Auto: "auto",
-  Concise: "concise",
-  Detailed: "detailed",
-} as const;
-export type GenerateSummary = ClosedEnum<typeof GenerateSummary>;
-
-export const Summary = {
-  Auto: "auto",
-  Concise: "concise",
-  Detailed: "detailed",
-} as const;
-export type Summary = ClosedEnum<typeof Summary>;
+export type ChatGenerationParamsEffort = OpenEnum<
+  typeof ChatGenerationParamsEffort
+>;
 
 export type Reasoning = {
-  effort?: Effort | null | undefined;
-  generateSummary?: GenerateSummary | null | undefined;
-  summary?: Summary | null | undefined;
+  effort?: ChatGenerationParamsEffort | null | undefined;
+  summary?: ReasoningSummaryVerbosity | null | undefined;
 };
 
-export type ResponseFormatPython = {
+export type ChatGenerationParamsResponseFormatPython = {
   type: "python";
 };
 
-export type ResponseFormatGrammar = {
-  type: "grammar";
-  grammar: string;
-};
-
-export type JsonSchema = {
-  name: string;
-  description?: string | undefined;
-  schema?: { [k: string]: any } | undefined;
-  strict?: boolean | null | undefined;
-};
-
-export type ResponseFormatJSONSchema = {
-  type: "json_schema";
-  jsonSchema: JsonSchema;
-};
-
-export type ResponseFormatJSONObject = {
+export type ChatGenerationParamsResponseFormatJSONObject = {
   type: "json_object";
 };
 
-export type ResponseFormatText = {
+export type ChatGenerationParamsResponseFormatText = {
   type: "text";
 };
 
-export type ResponseFormat =
+export type ChatGenerationParamsResponseFormatUnion =
   | ResponseFormatJSONSchema
-  | ResponseFormatGrammar
-  | ResponseFormatText
-  | ResponseFormatJSONObject
-  | ResponseFormatPython;
+  | ResponseFormatTextGrammar
+  | ChatGenerationParamsResponseFormatText
+  | ChatGenerationParamsResponseFormatJSONObject
+  | ChatGenerationParamsResponseFormatPython;
 
-export type Stop = string | Array<string>;
+export type ChatGenerationParamsStop = string | Array<string>;
 
 export type ChatGenerationParams = {
   messages: Array<Message>;
@@ -107,10 +98,10 @@ export type ChatGenerationParams = {
   reasoning?: Reasoning | undefined;
   responseFormat?:
     | ResponseFormatJSONSchema
-    | ResponseFormatGrammar
-    | ResponseFormatText
-    | ResponseFormatJSONObject
-    | ResponseFormatPython
+    | ResponseFormatTextGrammar
+    | ChatGenerationParamsResponseFormatText
+    | ChatGenerationParamsResponseFormatJSONObject
+    | ChatGenerationParamsResponseFormatPython
     | undefined;
   seed?: number | null | undefined;
   stop?: string | Array<string> | null | undefined;
@@ -124,62 +115,35 @@ export type ChatGenerationParams = {
 };
 
 /** @internal */
-export const Effort$inboundSchema: z.ZodNativeEnum<typeof Effort> = z
-  .nativeEnum(Effort);
-
-/** @internal */
-export const Effort$outboundSchema: z.ZodNativeEnum<typeof Effort> =
-  Effort$inboundSchema;
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace Effort$ {
-  /** @deprecated use `Effort$inboundSchema` instead. */
-  export const inboundSchema = Effort$inboundSchema;
-  /** @deprecated use `Effort$outboundSchema` instead. */
-  export const outboundSchema = Effort$outboundSchema;
-}
-
-/** @internal */
-export const GenerateSummary$inboundSchema: z.ZodNativeEnum<
-  typeof GenerateSummary
-> = z.nativeEnum(GenerateSummary);
-
-/** @internal */
-export const GenerateSummary$outboundSchema: z.ZodNativeEnum<
-  typeof GenerateSummary
-> = GenerateSummary$inboundSchema;
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace GenerateSummary$ {
-  /** @deprecated use `GenerateSummary$inboundSchema` instead. */
-  export const inboundSchema = GenerateSummary$inboundSchema;
-  /** @deprecated use `GenerateSummary$outboundSchema` instead. */
-  export const outboundSchema = GenerateSummary$outboundSchema;
-}
-
-/** @internal */
-export const Summary$inboundSchema: z.ZodNativeEnum<typeof Summary> = z
-  .nativeEnum(Summary);
+export const ChatGenerationParamsEffort$inboundSchema: z.ZodType<
+  ChatGenerationParamsEffort,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ChatGenerationParamsEffort),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const Summary$outboundSchema: z.ZodNativeEnum<typeof Summary> =
-  Summary$inboundSchema;
+export const ChatGenerationParamsEffort$outboundSchema: z.ZodType<
+  ChatGenerationParamsEffort,
+  z.ZodTypeDef,
+  ChatGenerationParamsEffort
+> = z.union([
+  z.nativeEnum(ChatGenerationParamsEffort),
+  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 Summary$ {
-  /** @deprecated use `Summary$inboundSchema` instead. */
-  export const inboundSchema = Summary$inboundSchema;
-  /** @deprecated use `Summary$outboundSchema` instead. */
-  export const outboundSchema = Summary$outboundSchema;
+export namespace ChatGenerationParamsEffort$ {
+  /** @deprecated use `ChatGenerationParamsEffort$inboundSchema` instead. */
+  export const inboundSchema = ChatGenerationParamsEffort$inboundSchema;
+  /** @deprecated use `ChatGenerationParamsEffort$outboundSchema` instead. */
+  export const outboundSchema = ChatGenerationParamsEffort$outboundSchema;
 }
 
 /** @internal */
@@ -188,19 +152,13 @@ export const Reasoning$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  effort: z.nullable(Effort$inboundSchema).optional(),
-  generate_summary: z.nullable(GenerateSummary$inboundSchema).optional(),
-  summary: z.nullable(Summary$inboundSchema).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "generate_summary": "generateSummary",
-  });
+  effort: z.nullable(ChatGenerationParamsEffort$inboundSchema).optional(),
+  summary: z.nullable(ReasoningSummaryVerbosity$inboundSchema).optional(),
 });
 
 /** @internal */
 export type Reasoning$Outbound = {
   effort?: string | null | undefined;
-  generate_summary?: string | null | undefined;
   summary?: string | null | undefined;
 };
 
@@ -210,13 +168,8 @@ export const Reasoning$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Reasoning
 > = z.object({
-  effort: z.nullable(Effort$outboundSchema).optional(),
-  generateSummary: z.nullable(GenerateSummary$outboundSchema).optional(),
-  summary: z.nullable(Summary$outboundSchema).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    generateSummary: "generate_summary",
-  });
+  effort: z.nullable(ChatGenerationParamsEffort$outboundSchema).optional(),
+  summary: z.nullable(ReasoningSummaryVerbosity$outboundSchema).optional(),
 });
 
 /**
@@ -247,8 +200,8 @@ export function reasoningFromJSON(
 }
 
 /** @internal */
-export const ResponseFormatPython$inboundSchema: z.ZodType<
-  ResponseFormatPython,
+export const ChatGenerationParamsResponseFormatPython$inboundSchema: z.ZodType<
+  ChatGenerationParamsResponseFormatPython,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -256,15 +209,15 @@ export const ResponseFormatPython$inboundSchema: z.ZodType<
 });
 
 /** @internal */
-export type ResponseFormatPython$Outbound = {
+export type ChatGenerationParamsResponseFormatPython$Outbound = {
   type: "python";
 };
 
 /** @internal */
-export const ResponseFormatPython$outboundSchema: z.ZodType<
-  ResponseFormatPython$Outbound,
+export const ChatGenerationParamsResponseFormatPython$outboundSchema: z.ZodType<
+  ChatGenerationParamsResponseFormatPython$Outbound,
   z.ZodTypeDef,
-  ResponseFormatPython
+  ChatGenerationParamsResponseFormatPython
 > = z.object({
   type: z.literal("python"),
 });
@@ -273,271 +226,114 @@ export const ResponseFormatPython$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 ResponseFormatPython$ {
-  /** @deprecated use `ResponseFormatPython$inboundSchema` instead. */
-  export const inboundSchema = ResponseFormatPython$inboundSchema;
-  /** @deprecated use `ResponseFormatPython$outboundSchema` instead. */
-  export const outboundSchema = ResponseFormatPython$outboundSchema;
-  /** @deprecated use `ResponseFormatPython$Outbound` instead. */
-  export type Outbound = ResponseFormatPython$Outbound;
-}
-
-export function responseFormatPythonToJSON(
-  responseFormatPython: ResponseFormatPython,
-): string {
-  return JSON.stringify(
-    ResponseFormatPython$outboundSchema.parse(responseFormatPython),
-  );
-}
-
-export function responseFormatPythonFromJSON(
-  jsonString: string,
-): SafeParseResult<ResponseFormatPython, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ResponseFormatPython$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ResponseFormatPython' from JSON`,
-  );
-}
-
-/** @internal */
-export const ResponseFormatGrammar$inboundSchema: z.ZodType<
-  ResponseFormatGrammar,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  type: z.literal("grammar"),
-  grammar: z.string(),
-});
-
-/** @internal */
-export type ResponseFormatGrammar$Outbound = {
-  type: "grammar";
-  grammar: string;
-};
-
-/** @internal */
-export const ResponseFormatGrammar$outboundSchema: z.ZodType<
-  ResponseFormatGrammar$Outbound,
-  z.ZodTypeDef,
-  ResponseFormatGrammar
-> = z.object({
-  type: z.literal("grammar"),
-  grammar: 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 ResponseFormatGrammar$ {
-  /** @deprecated use `ResponseFormatGrammar$inboundSchema` instead. */
-  export const inboundSchema = ResponseFormatGrammar$inboundSchema;
-  /** @deprecated use `ResponseFormatGrammar$outboundSchema` instead. */
-  export const outboundSchema = ResponseFormatGrammar$outboundSchema;
-  /** @deprecated use `ResponseFormatGrammar$Outbound` instead. */
-  export type Outbound = ResponseFormatGrammar$Outbound;
-}
-
-export function responseFormatGrammarToJSON(
-  responseFormatGrammar: ResponseFormatGrammar,
+export namespace ChatGenerationParamsResponseFormatPython$ {
+  /** @deprecated use `ChatGenerationParamsResponseFormatPython$inboundSchema` instead. */
+  export const inboundSchema =
+    ChatGenerationParamsResponseFormatPython$inboundSchema;
+  /** @deprecated use `ChatGenerationParamsResponseFormatPython$outboundSchema` instead. */
+  export const outboundSchema =
+    ChatGenerationParamsResponseFormatPython$outboundSchema;
+  /** @deprecated use `ChatGenerationParamsResponseFormatPython$Outbound` instead. */
+  export type Outbound = ChatGenerationParamsResponseFormatPython$Outbound;
+}
+
+export function chatGenerationParamsResponseFormatPythonToJSON(
+  chatGenerationParamsResponseFormatPython:
+    ChatGenerationParamsResponseFormatPython,
 ): string {
   return JSON.stringify(
-    ResponseFormatGrammar$outboundSchema.parse(responseFormatGrammar),
+    ChatGenerationParamsResponseFormatPython$outboundSchema.parse(
+      chatGenerationParamsResponseFormatPython,
+    ),
   );
 }
 
-export function responseFormatGrammarFromJSON(
+export function chatGenerationParamsResponseFormatPythonFromJSON(
   jsonString: string,
-): SafeParseResult<ResponseFormatGrammar, SDKValidationError> {
+): SafeParseResult<
+  ChatGenerationParamsResponseFormatPython,
+  SDKValidationError
+> {
   return safeParse(
     jsonString,
-    (x) => ResponseFormatGrammar$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ResponseFormatGrammar' from JSON`,
+    (x) =>
+      ChatGenerationParamsResponseFormatPython$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ChatGenerationParamsResponseFormatPython' from JSON`,
   );
 }
 
 /** @internal */
-export const JsonSchema$inboundSchema: z.ZodType<
-  JsonSchema,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-  schema: z.record(z.any()).optional(),
-  strict: z.nullable(z.boolean()).optional(),
-});
-
-/** @internal */
-export type JsonSchema$Outbound = {
-  name: string;
-  description?: string | undefined;
-  schema?: { [k: string]: any } | undefined;
-  strict?: boolean | null | undefined;
-};
-
-/** @internal */
-export const JsonSchema$outboundSchema: z.ZodType<
-  JsonSchema$Outbound,
-  z.ZodTypeDef,
-  JsonSchema
-> = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-  schema: z.record(z.any()).optional(),
-  strict: z.nullable(z.boolean()).optional(),
-});
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace JsonSchema$ {
-  /** @deprecated use `JsonSchema$inboundSchema` instead. */
-  export const inboundSchema = JsonSchema$inboundSchema;
-  /** @deprecated use `JsonSchema$outboundSchema` instead. */
-  export const outboundSchema = JsonSchema$outboundSchema;
-  /** @deprecated use `JsonSchema$Outbound` instead. */
-  export type Outbound = JsonSchema$Outbound;
-}
-
-export function jsonSchemaToJSON(jsonSchema: JsonSchema): string {
-  return JSON.stringify(JsonSchema$outboundSchema.parse(jsonSchema));
-}
-
-export function jsonSchemaFromJSON(
-  jsonString: string,
-): SafeParseResult<JsonSchema, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => JsonSchema$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'JsonSchema' from JSON`,
-  );
-}
-
-/** @internal */
-export const ResponseFormatJSONSchema$inboundSchema: z.ZodType<
-  ResponseFormatJSONSchema,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  type: z.literal("json_schema"),
-  json_schema: z.lazy(() => JsonSchema$inboundSchema),
-}).transform((v) => {
-  return remap$(v, {
-    "json_schema": "jsonSchema",
+export const ChatGenerationParamsResponseFormatJSONObject$inboundSchema:
+  z.ZodType<
+    ChatGenerationParamsResponseFormatJSONObject,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    type: z.literal("json_object"),
   });
-});
-
-/** @internal */
-export type ResponseFormatJSONSchema$Outbound = {
-  type: "json_schema";
-  json_schema: JsonSchema$Outbound;
-};
-
-/** @internal */
-export const ResponseFormatJSONSchema$outboundSchema: z.ZodType<
-  ResponseFormatJSONSchema$Outbound,
-  z.ZodTypeDef,
-  ResponseFormatJSONSchema
-> = z.object({
-  type: z.literal("json_schema"),
-  jsonSchema: z.lazy(() => JsonSchema$outboundSchema),
-}).transform((v) => {
-  return remap$(v, {
-    jsonSchema: "json_schema",
-  });
-});
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace ResponseFormatJSONSchema$ {
-  /** @deprecated use `ResponseFormatJSONSchema$inboundSchema` instead. */
-  export const inboundSchema = ResponseFormatJSONSchema$inboundSchema;
-  /** @deprecated use `ResponseFormatJSONSchema$outboundSchema` instead. */
-  export const outboundSchema = ResponseFormatJSONSchema$outboundSchema;
-  /** @deprecated use `ResponseFormatJSONSchema$Outbound` instead. */
-  export type Outbound = ResponseFormatJSONSchema$Outbound;
-}
-
-export function responseFormatJSONSchemaToJSON(
-  responseFormatJSONSchema: ResponseFormatJSONSchema,
-): string {
-  return JSON.stringify(
-    ResponseFormatJSONSchema$outboundSchema.parse(responseFormatJSONSchema),
-  );
-}
-
-export function responseFormatJSONSchemaFromJSON(
-  jsonString: string,
-): SafeParseResult<ResponseFormatJSONSchema, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ResponseFormatJSONSchema$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ResponseFormatJSONSchema' from JSON`,
-  );
-}
-
-/** @internal */
-export const ResponseFormatJSONObject$inboundSchema: z.ZodType<
-  ResponseFormatJSONObject,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  type: z.literal("json_object"),
-});
 
 /** @internal */
-export type ResponseFormatJSONObject$Outbound = {
+export type ChatGenerationParamsResponseFormatJSONObject$Outbound = {
   type: "json_object";
 };
 
 /** @internal */
-export const ResponseFormatJSONObject$outboundSchema: z.ZodType<
-  ResponseFormatJSONObject$Outbound,
-  z.ZodTypeDef,
-  ResponseFormatJSONObject
-> = z.object({
-  type: z.literal("json_object"),
-});
+export const ChatGenerationParamsResponseFormatJSONObject$outboundSchema:
+  z.ZodType<
+    ChatGenerationParamsResponseFormatJSONObject$Outbound,
+    z.ZodTypeDef,
+    ChatGenerationParamsResponseFormatJSONObject
+  > = z.object({
+    type: z.literal("json_object"),
+  });
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace ResponseFormatJSONObject$ {
-  /** @deprecated use `ResponseFormatJSONObject$inboundSchema` instead. */
-  export const inboundSchema = ResponseFormatJSONObject$inboundSchema;
-  /** @deprecated use `ResponseFormatJSONObject$outboundSchema` instead. */
-  export const outboundSchema = ResponseFormatJSONObject$outboundSchema;
-  /** @deprecated use `ResponseFormatJSONObject$Outbound` instead. */
-  export type Outbound = ResponseFormatJSONObject$Outbound;
-}
-
-export function responseFormatJSONObjectToJSON(
-  responseFormatJSONObject: ResponseFormatJSONObject,
+export namespace ChatGenerationParamsResponseFormatJSONObject$ {
+  /** @deprecated use `ChatGenerationParamsResponseFormatJSONObject$inboundSchema` instead. */
+  export const inboundSchema =
+    ChatGenerationParamsResponseFormatJSONObject$inboundSchema;
+  /** @deprecated use `ChatGenerationParamsResponseFormatJSONObject$outboundSchema` instead. */
+  export const outboundSchema =
+    ChatGenerationParamsResponseFormatJSONObject$outboundSchema;
+  /** @deprecated use `ChatGenerationParamsResponseFormatJSONObject$Outbound` instead. */
+  export type Outbound = ChatGenerationParamsResponseFormatJSONObject$Outbound;
+}
+
+export function chatGenerationParamsResponseFormatJSONObjectToJSON(
+  chatGenerationParamsResponseFormatJSONObject:
+    ChatGenerationParamsResponseFormatJSONObject,
 ): string {
   return JSON.stringify(
-    ResponseFormatJSONObject$outboundSchema.parse(responseFormatJSONObject),
+    ChatGenerationParamsResponseFormatJSONObject$outboundSchema.parse(
+      chatGenerationParamsResponseFormatJSONObject,
+    ),
   );
 }
 
-export function responseFormatJSONObjectFromJSON(
+export function chatGenerationParamsResponseFormatJSONObjectFromJSON(
   jsonString: string,
-): SafeParseResult<ResponseFormatJSONObject, SDKValidationError> {
+): SafeParseResult<
+  ChatGenerationParamsResponseFormatJSONObject,
+  SDKValidationError
+> {
   return safeParse(
     jsonString,
-    (x) => ResponseFormatJSONObject$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ResponseFormatJSONObject' from JSON`,
+    (x) =>
+      ChatGenerationParamsResponseFormatJSONObject$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ChatGenerationParamsResponseFormatJSONObject' from JSON`,
   );
 }
 
 /** @internal */
-export const ResponseFormatText$inboundSchema: z.ZodType<
-  ResponseFormatText,
+export const ChatGenerationParamsResponseFormatText$inboundSchema: z.ZodType<
+  ChatGenerationParamsResponseFormatText,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -545,15 +341,15 @@ export const ResponseFormatText$inboundSchema: z.ZodType<
 });
 
 /** @internal */
-export type ResponseFormatText$Outbound = {
+export type ChatGenerationParamsResponseFormatText$Outbound = {
   type: "text";
 };
 
 /** @internal */
-export const ResponseFormatText$outboundSchema: z.ZodType<
-  ResponseFormatText$Outbound,
+export const ChatGenerationParamsResponseFormatText$outboundSchema: z.ZodType<
+  ChatGenerationParamsResponseFormatText$Outbound,
   z.ZodTypeDef,
-  ResponseFormatText
+  ChatGenerationParamsResponseFormatText
 > = z.object({
   type: z.literal("text"),
 });
@@ -562,129 +358,160 @@ export const ResponseFormatText$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 ResponseFormatText$ {
-  /** @deprecated use `ResponseFormatText$inboundSchema` instead. */
-  export const inboundSchema = ResponseFormatText$inboundSchema;
-  /** @deprecated use `ResponseFormatText$outboundSchema` instead. */
-  export const outboundSchema = ResponseFormatText$outboundSchema;
-  /** @deprecated use `ResponseFormatText$Outbound` instead. */
-  export type Outbound = ResponseFormatText$Outbound;
-}
-
-export function responseFormatTextToJSON(
-  responseFormatText: ResponseFormatText,
+export namespace ChatGenerationParamsResponseFormatText$ {
+  /** @deprecated use `ChatGenerationParamsResponseFormatText$inboundSchema` instead. */
+  export const inboundSchema =
+    ChatGenerationParamsResponseFormatText$inboundSchema;
+  /** @deprecated use `ChatGenerationParamsResponseFormatText$outboundSchema` instead. */
+  export const outboundSchema =
+    ChatGenerationParamsResponseFormatText$outboundSchema;
+  /** @deprecated use `ChatGenerationParamsResponseFormatText$Outbound` instead. */
+  export type Outbound = ChatGenerationParamsResponseFormatText$Outbound;
+}
+
+export function chatGenerationParamsResponseFormatTextToJSON(
+  chatGenerationParamsResponseFormatText:
+    ChatGenerationParamsResponseFormatText,
 ): string {
   return JSON.stringify(
-    ResponseFormatText$outboundSchema.parse(responseFormatText),
+    ChatGenerationParamsResponseFormatText$outboundSchema.parse(
+      chatGenerationParamsResponseFormatText,
+    ),
   );
 }
 
-export function responseFormatTextFromJSON(
+export function chatGenerationParamsResponseFormatTextFromJSON(
   jsonString: string,
-): SafeParseResult<ResponseFormatText, SDKValidationError> {
+): SafeParseResult<ChatGenerationParamsResponseFormatText, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ResponseFormatText$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ResponseFormatText' from JSON`,
+    (x) =>
+      ChatGenerationParamsResponseFormatText$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChatGenerationParamsResponseFormatText' from JSON`,
   );
 }
 
 /** @internal */
-export const ResponseFormat$inboundSchema: z.ZodType<
-  ResponseFormat,
+export const ChatGenerationParamsResponseFormatUnion$inboundSchema: z.ZodType<
+  ChatGenerationParamsResponseFormatUnion,
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.lazy(() => ResponseFormatJSONSchema$inboundSchema),
-  z.lazy(() => ResponseFormatGrammar$inboundSchema),
-  z.lazy(() => ResponseFormatText$inboundSchema),
-  z.lazy(() => ResponseFormatJSONObject$inboundSchema),
-  z.lazy(() => ResponseFormatPython$inboundSchema),
+  ResponseFormatJSONSchema$inboundSchema,
+  ResponseFormatTextGrammar$inboundSchema,
+  z.lazy(() => ChatGenerationParamsResponseFormatText$inboundSchema),
+  z.lazy(() => ChatGenerationParamsResponseFormatJSONObject$inboundSchema),
+  z.lazy(() => ChatGenerationParamsResponseFormatPython$inboundSchema),
 ]);
 
 /** @internal */
-export type ResponseFormat$Outbound =
+export type ChatGenerationParamsResponseFormatUnion$Outbound =
   | ResponseFormatJSONSchema$Outbound
-  | ResponseFormatGrammar$Outbound
-  | ResponseFormatText$Outbound
-  | ResponseFormatJSONObject$Outbound
-  | ResponseFormatPython$Outbound;
+  | ResponseFormatTextGrammar$Outbound
+  | ChatGenerationParamsResponseFormatText$Outbound
+  | ChatGenerationParamsResponseFormatJSONObject$Outbound
+  | ChatGenerationParamsResponseFormatPython$Outbound;
 
 /** @internal */
-export const ResponseFormat$outboundSchema: z.ZodType<
-  ResponseFormat$Outbound,
+export const ChatGenerationParamsResponseFormatUnion$outboundSchema: z.ZodType<
+  ChatGenerationParamsResponseFormatUnion$Outbound,
   z.ZodTypeDef,
-  ResponseFormat
+  ChatGenerationParamsResponseFormatUnion
 > = z.union([
-  z.lazy(() => ResponseFormatJSONSchema$outboundSchema),
-  z.lazy(() => ResponseFormatGrammar$outboundSchema),
-  z.lazy(() => ResponseFormatText$outboundSchema),
-  z.lazy(() => ResponseFormatJSONObject$outboundSchema),
-  z.lazy(() => ResponseFormatPython$outboundSchema),
+  ResponseFormatJSONSchema$outboundSchema,
+  ResponseFormatTextGrammar$outboundSchema,
+  z.lazy(() => ChatGenerationParamsResponseFormatText$outboundSchema),
+  z.lazy(() => ChatGenerationParamsResponseFormatJSONObject$outboundSchema),
+  z.lazy(() => ChatGenerationParamsResponseFormatPython$outboundSchema),
 ]);
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace ResponseFormat$ {
-  /** @deprecated use `ResponseFormat$inboundSchema` instead. */
-  export const inboundSchema = ResponseFormat$inboundSchema;
-  /** @deprecated use `ResponseFormat$outboundSchema` instead. */
-  export const outboundSchema = ResponseFormat$outboundSchema;
-  /** @deprecated use `ResponseFormat$Outbound` instead. */
-  export type Outbound = ResponseFormat$Outbound;
-}
-
-export function responseFormatToJSON(responseFormat: ResponseFormat): string {
-  return JSON.stringify(ResponseFormat$outboundSchema.parse(responseFormat));
+export namespace ChatGenerationParamsResponseFormatUnion$ {
+  /** @deprecated use `ChatGenerationParamsResponseFormatUnion$inboundSchema` instead. */
+  export const inboundSchema =
+    ChatGenerationParamsResponseFormatUnion$inboundSchema;
+  /** @deprecated use `ChatGenerationParamsResponseFormatUnion$outboundSchema` instead. */
+  export const outboundSchema =
+    ChatGenerationParamsResponseFormatUnion$outboundSchema;
+  /** @deprecated use `ChatGenerationParamsResponseFormatUnion$Outbound` instead. */
+  export type Outbound = ChatGenerationParamsResponseFormatUnion$Outbound;
+}
+
+export function chatGenerationParamsResponseFormatUnionToJSON(
+  chatGenerationParamsResponseFormatUnion:
+    ChatGenerationParamsResponseFormatUnion,
+): string {
+  return JSON.stringify(
+    ChatGenerationParamsResponseFormatUnion$outboundSchema.parse(
+      chatGenerationParamsResponseFormatUnion,
+    ),
+  );
 }
 
-export function responseFormatFromJSON(
+export function chatGenerationParamsResponseFormatUnionFromJSON(
   jsonString: string,
-): SafeParseResult<ResponseFormat, SDKValidationError> {
+): SafeParseResult<
+  ChatGenerationParamsResponseFormatUnion,
+  SDKValidationError
+> {
   return safeParse(
     jsonString,
-    (x) => ResponseFormat$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ResponseFormat' from JSON`,
+    (x) =>
+      ChatGenerationParamsResponseFormatUnion$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ChatGenerationParamsResponseFormatUnion' from JSON`,
   );
 }
 
 /** @internal */
-export const Stop$inboundSchema: z.ZodType<Stop, z.ZodTypeDef, unknown> = z
-  .union([z.string(), z.array(z.string())]);
+export const ChatGenerationParamsStop$inboundSchema: z.ZodType<
+  ChatGenerationParamsStop,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.string(), z.array(z.string())]);
 
 /** @internal */
-export type Stop$Outbound = string | Array<string>;
+export type ChatGenerationParamsStop$Outbound = string | Array<string>;
 
 /** @internal */
-export const Stop$outboundSchema: z.ZodType<Stop$Outbound, z.ZodTypeDef, Stop> =
-  z.union([z.string(), z.array(z.string())]);
+export const ChatGenerationParamsStop$outboundSchema: z.ZodType<
+  ChatGenerationParamsStop$Outbound,
+  z.ZodTypeDef,
+  ChatGenerationParamsStop
+> = z.union([z.string(), z.array(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 Stop$ {
-  /** @deprecated use `Stop$inboundSchema` instead. */
-  export const inboundSchema = Stop$inboundSchema;
-  /** @deprecated use `Stop$outboundSchema` instead. */
-  export const outboundSchema = Stop$outboundSchema;
-  /** @deprecated use `Stop$Outbound` instead. */
-  export type Outbound = Stop$Outbound;
+export namespace ChatGenerationParamsStop$ {
+  /** @deprecated use `ChatGenerationParamsStop$inboundSchema` instead. */
+  export const inboundSchema = ChatGenerationParamsStop$inboundSchema;
+  /** @deprecated use `ChatGenerationParamsStop$outboundSchema` instead. */
+  export const outboundSchema = ChatGenerationParamsStop$outboundSchema;
+  /** @deprecated use `ChatGenerationParamsStop$Outbound` instead. */
+  export type Outbound = ChatGenerationParamsStop$Outbound;
 }
 
-export function stopToJSON(stop: Stop): string {
-  return JSON.stringify(Stop$outboundSchema.parse(stop));
+export function chatGenerationParamsStopToJSON(
+  chatGenerationParamsStop: ChatGenerationParamsStop,
+): string {
+  return JSON.stringify(
+    ChatGenerationParamsStop$outboundSchema.parse(chatGenerationParamsStop),
+  );
 }
 
-export function stopFromJSON(
+export function chatGenerationParamsStopFromJSON(
   jsonString: string,
-): SafeParseResult<Stop, SDKValidationError> {
+): SafeParseResult<ChatGenerationParamsStop, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Stop$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Stop' from JSON`,
+    (x) => ChatGenerationParamsStop$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChatGenerationParamsStop' from JSON`,
   );
 }
 
@@ -706,11 +533,11 @@ export const ChatGenerationParams$inboundSchema: z.ZodType<
   presence_penalty: z.nullable(z.number()).optional(),
   reasoning: z.lazy(() => Reasoning$inboundSchema).optional(),
   response_format: z.union([
-    z.lazy(() => ResponseFormatJSONSchema$inboundSchema),
-    z.lazy(() => ResponseFormatGrammar$inboundSchema),
-    z.lazy(() => ResponseFormatText$inboundSchema),
-    z.lazy(() => ResponseFormatJSONObject$inboundSchema),
-    z.lazy(() => ResponseFormatPython$inboundSchema),
+    ResponseFormatJSONSchema$inboundSchema,
+    ResponseFormatTextGrammar$inboundSchema,
+    z.lazy(() => ChatGenerationParamsResponseFormatText$inboundSchema),
+    z.lazy(() => ChatGenerationParamsResponseFormatJSONObject$inboundSchema),
+    z.lazy(() => ChatGenerationParamsResponseFormatPython$inboundSchema),
   ]).optional(),
   seed: z.nullable(z.number().int()).optional(),
   stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),
@@ -751,10 +578,10 @@ export type ChatGenerationParams$Outbound = {
   reasoning?: Reasoning$Outbound | undefined;
   response_format?:
     | ResponseFormatJSONSchema$Outbound
-    | ResponseFormatGrammar$Outbound
-    | ResponseFormatText$Outbound
-    | ResponseFormatJSONObject$Outbound
-    | ResponseFormatPython$Outbound
+    | ResponseFormatTextGrammar$Outbound
+    | ChatGenerationParamsResponseFormatText$Outbound
+    | ChatGenerationParamsResponseFormatJSONObject$Outbound
+    | ChatGenerationParamsResponseFormatPython$Outbound
     | undefined;
   seed?: number | null | undefined;
   stop?: string | Array<string> | null | undefined;
@@ -785,11 +612,11 @@ export const ChatGenerationParams$outboundSchema: z.ZodType<
   presencePenalty: z.nullable(z.number()).optional(),
   reasoning: z.lazy(() => Reasoning$outboundSchema).optional(),
   responseFormat: z.union([
-    z.lazy(() => ResponseFormatJSONSchema$outboundSchema),
-    z.lazy(() => ResponseFormatGrammar$outboundSchema),
-    z.lazy(() => ResponseFormatText$outboundSchema),
-    z.lazy(() => ResponseFormatJSONObject$outboundSchema),
-    z.lazy(() => ResponseFormatPython$outboundSchema),
+    ResponseFormatJSONSchema$outboundSchema,
+    ResponseFormatTextGrammar$outboundSchema,
+    z.lazy(() => ChatGenerationParamsResponseFormatText$outboundSchema),
+    z.lazy(() => ChatGenerationParamsResponseFormatJSONObject$outboundSchema),
+    z.lazy(() => ChatGenerationParamsResponseFormatPython$outboundSchema),
   ]).optional(),
   seed: z.nullable(z.number().int()).optional(),
   stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),