@openrouter/sdk 0.0.0-beta.38 → 0.0.0-beta.39

package/src/funcs/custom/oAuthCreateSHA256CodeChallenge.test.ts

@@ -0,0 +1,189 @@
+import { describe, it, expect } from "vitest";
+import { oAuthCreateSHA256CodeChallenge } from "./oAuthCreateSHA256CodeChallenge.js";
+
+describe("oAuthCreateSHA256CodeChallenge", () => {
+  it("should generate code challenge from provided code verifier", async () => {
+    // Use RFC 7636 compliant verifier (43 chars minimum)
+    const codeVerifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
+    const result = await oAuthCreateSHA256CodeChallenge({ codeVerifier });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.codeVerifier).toBe(codeVerifier);
+      expect(result.value.codeChallenge).toBeTruthy();
+      expect(typeof result.value.codeChallenge).toBe("string");
+      // Code challenge should be base64url encoded (no +, /, or = characters)
+      expect(result.value.codeChallenge).not.toMatch(/[+/=]/);
+    }
+  });
+
+  it("should generate consistent code challenge for same verifier", async () => {
+    // RFC compliant verifier (43+ chars)
+    const codeVerifier = "a".repeat(43);
+    const result1 = await oAuthCreateSHA256CodeChallenge({ codeVerifier });
+    const result2 = await oAuthCreateSHA256CodeChallenge({ codeVerifier });
+
+    expect(result1.ok).toBe(true);
+    expect(result2.ok).toBe(true);
+    if (result1.ok && result2.ok) {
+      expect(result1.value.codeChallenge).toBe(result2.value.codeChallenge);
+    }
+  });
+
+  it("should generate RFC 7636 compliant random code verifier when not provided", async () => {
+    const result = await oAuthCreateSHA256CodeChallenge();
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.codeVerifier).toBeTruthy();
+      expect(result.value.codeChallenge).toBeTruthy();
+      expect(typeof result.value.codeVerifier).toBe("string");
+      // RFC 7636: verifier should be exactly 43 characters (32 bytes base64url encoded)
+      expect(result.value.codeVerifier.length).toBe(43);
+      // Should only contain base64url characters
+      expect(result.value.codeVerifier).toMatch(/^[A-Za-z0-9_-]+$/);
+    }
+  });
+
+  it("should generate different code verifiers on successive calls", async () => {
+    const result1 = await oAuthCreateSHA256CodeChallenge();
+    const result2 = await oAuthCreateSHA256CodeChallenge();
+
+    expect(result1.ok).toBe(true);
+    expect(result2.ok).toBe(true);
+    if (result1.ok && result2.ok) {
+      expect(result1.value.codeVerifier).not.toBe(result2.value.codeVerifier);
+      expect(result1.value.codeChallenge).not.toBe(result2.value.codeChallenge);
+    }
+  });
+
+  it("should generate base64url encoded challenge (RFC 7636)", async () => {
+    const codeVerifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
+    const result = await oAuthCreateSHA256CodeChallenge({ codeVerifier });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      // Should be base64url encoded (no standard base64 chars)
+      expect(result.value.codeChallenge).not.toMatch(/\+/);
+      expect(result.value.codeChallenge).not.toMatch(/\//);
+      expect(result.value.codeChallenge).not.toMatch(/=/);
+      // Should only contain base64url characters
+      expect(result.value.codeChallenge).toMatch(/^[A-Za-z0-9_-]+$/);
+    }
+  });
+
+  it("should handle invalid input type", async () => {
+    const result = await oAuthCreateSHA256CodeChallenge({
+      codeVerifier: 123 as any,
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeDefined();
+    }
+  });
+
+  it("should produce SHA-256 hash of correct length", async () => {
+    const codeVerifier = "a".repeat(43); // RFC compliant length
+    const result = await oAuthCreateSHA256CodeChallenge({ codeVerifier });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      // SHA-256 produces 256 bits = 32 bytes
+      // Base64url encoding of 32 bytes should be 43 characters (no padding)
+      expect(result.value.codeChallenge.length).toBe(43);
+    }
+  });
+
+  it("should reject empty string code verifier (RFC 7636 violation)", async () => {
+    const result = await oAuthCreateSHA256CodeChallenge({ codeVerifier: "" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeDefined();
+      expect((result.error as Error).message).toContain("at least 43 characters");
+    }
+  });
+
+  it("should reject code verifier shorter than 43 characters", async () => {
+    const result = await oAuthCreateSHA256CodeChallenge({
+      codeVerifier: "too-short",
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeDefined();
+      expect((result.error as Error).message).toContain("at least 43 characters");
+    }
+  });
+
+  it("should reject code verifier longer than 128 characters (RFC 7636)", async () => {
+    const longVerifier = "a".repeat(129);
+    const result = await oAuthCreateSHA256CodeChallenge({
+      codeVerifier: longVerifier,
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeDefined();
+      expect((result.error as Error).message).toContain("at most 128 characters");
+    }
+  });
+
+  it("should accept code verifier at maximum length (128 characters)", async () => {
+    const maxVerifier = "a".repeat(128);
+    const result = await oAuthCreateSHA256CodeChallenge({
+      codeVerifier: maxVerifier,
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.codeVerifier).toBe(maxVerifier);
+      expect(result.value.codeChallenge).toBeTruthy();
+      // SHA-256 always produces same length output regardless of input length
+      expect(result.value.codeChallenge.length).toBe(43);
+    }
+  });
+
+  it("should accept RFC 7636 unreserved characters in code verifier", async () => {
+    // RFC 7636 allows: [A-Z] / [a-z] / [0-9] / "-" / "." / "_" / "~"
+    const validVerifier = "aZ09-._~" + "a".repeat(35); // 43 chars total
+    const result = await oAuthCreateSHA256CodeChallenge({
+      codeVerifier: validVerifier,
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.codeVerifier).toBe(validVerifier);
+      expect(result.value.codeChallenge).toBeTruthy();
+      expect(result.value.codeChallenge.length).toBe(43);
+    }
+  });
+
+  it("should reject code verifier with invalid characters", async () => {
+    // Contains invalid characters like ! @ # $ etc.
+    const invalidVerifier = "test!@#$%^&*()+=[]{}|;:',.<>?/`" + "a".repeat(13);
+    const result = await oAuthCreateSHA256CodeChallenge({
+      codeVerifier: invalidVerifier,
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeDefined();
+      expect((result.error as Error).message).toContain("unreserved characters");
+    }
+  });
+
+  it("should reject code verifier with spaces", async () => {
+    const verifierWithSpaces = "test verifier with spaces" + "a".repeat(18);
+    const result = await oAuthCreateSHA256CodeChallenge({
+      codeVerifier: verifierWithSpaces,
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeDefined();
+      expect((result.error as Error).message).toContain("unreserved characters");
+    }
+  });
+});

package/src/funcs/custom/oAuthCreateSHA256CodeChallenge.ts

@@ -0,0 +1,90 @@
+import z from "zod/v3";
+import { Result } from "../../types/fp.js";
+
+const CreateSHA256CodeChallengeRequestSchema = z.object({
+  /**
+   * If not provided, a random code verifier will be generated.
+   * If provided, must be 43-128 characters and contain only unreserved
+   * characters [A-Za-z0-9-._~] per RFC 7636.
+   */
+  codeVerifier: z
+    .string()
+    .min(43, "Code verifier must be at least 43 characters")
+    .max(128, "Code verifier must be at most 128 characters")
+    .regex(
+      /^[A-Za-z0-9\-._~]+$/,
+      "Code verifier must only contain unreserved characters: [A-Za-z0-9-._~]",
+    )
+    .optional(),
+});
+
+export type CreateSHA256CodeChallengeRequest = z.infer<
+  typeof CreateSHA256CodeChallengeRequestSchema
+>;
+
+export type CreateSHA256CodeChallengeResponse = {
+  codeChallenge: string;
+  codeVerifier: string;
+};
+
+/**
+ * Convert a Uint8Array to base64url encoding (RFC 4648)
+ */
+function arrayBufferToBase64Url(buffer: Uint8Array): string {
+  let binary = "";
+  for (let i = 0; i < buffer.length; i++) {
+    binary += String.fromCharCode(buffer[i]!);
+  }
+  return btoa(binary)
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=+$/, "");
+}
+
+/**
+ * Generate a cryptographically random code verifier per RFC 7636
+ */
+function generateCodeVerifier(): string {
+  // RFC 7636 recommends 32 octets of random data, base64url encoded = 43 chars
+  const randomBytes = crypto.getRandomValues(new Uint8Array(32));
+  return arrayBufferToBase64Url(randomBytes);
+}
+
+/**
+ * Generate a SHA-256 code challenge for PKCE
+ *
+ * @remarks
+ * Generates a SHA-256 code challenge and corresponding code verifier for use
+ * in the PKCE extension to OAuth2. If no code verifier is provided, a random
+ * one will be generated according to RFC 7636 (32 random bytes, base64url
+ * encoded). If a code verifier is provided, it must be 43-128 characters and
+ * contain only unreserved characters [A-Za-z0-9-._~].
+ *
+ * @see {@link https://openrouter.ai/docs/use-cases/oauth-pkce}
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc7636}
+ */
+export async function oAuthCreateSHA256CodeChallenge(
+  params: CreateSHA256CodeChallengeRequest = {},
+): Promise<Result<CreateSHA256CodeChallengeResponse>> {
+  const parsedParams = CreateSHA256CodeChallengeRequestSchema.safeParse(params);
+  if (!parsedParams.success) return { ok: false, error: parsedParams.error };
+
+  const { codeVerifier = generateCodeVerifier() } = parsedParams.data;
+
+  // Generate SHA-256 hash
+  const encoder = new TextEncoder();
+  const data = encoder.encode(codeVerifier);
+  const hash = await crypto.subtle.digest("SHA-256", data);
+
+  // Convert hash to base64url
+  const hashArray = new Uint8Array(hash);
+  const codeChallenge = arrayBufferToBase64Url(hashArray);
+
+  return {
+    ok: true,
+    value: {
+      codeChallenge,
+      codeVerifier,
+    },
+  };
+}

package/src/funcs/modelsList.ts

@@ -96,7 +96,7 @@ async function $do(
   });
 
   const headers = new Headers(compactMap({
-    Accept: "application/json;q=1",
+    Accept: "application/json;q=1, application/rss+xml;q=0",
   }));
 
   const secConfig = await extractSecurity(client._options.apiKey);

package/src/lib/config.ts

@@ -59,8 +59,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.0.0",
-  sdkVersion: "0.0.0-beta.38",
-  genVersion: "2.723.8",
+  sdkVersion: "0.0.0-beta.39",
+  genVersion: "2.723.11",
   userAgent:
-    "speakeasy-sdk/typescript 0.0.0-beta.38 2.723.8 1.0.0 @openrouter/sdk",
+    "speakeasy-sdk/typescript 0.0.0-beta.39 2.723.11 1.0.0 @openrouter/sdk",
 } as const;

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,
@@ -33,7 +37,7 @@ export const ChatGenerationParamsEffort = {
   Medium: "medium",
   High: "high",
 } as const;
-export type ChatGenerationParamsEffort = ClosedEnum<
+export type ChatGenerationParamsEffort = OpenEnum<
   typeof ChatGenerationParamsEffort
 >;
 
@@ -42,14 +46,14 @@ export const GenerateSummary = {
   Concise: "concise",
   Detailed: "detailed",
 } as const;
-export type GenerateSummary = ClosedEnum<typeof GenerateSummary>;
+export type GenerateSummary = OpenEnum<typeof GenerateSummary>;
 
 export const SummaryEnum = {
   Auto: "auto",
   Concise: "concise",
   Detailed: "detailed",
 } as const;
-export type SummaryEnum = ClosedEnum<typeof SummaryEnum>;
+export type SummaryEnum = OpenEnum<typeof SummaryEnum>;
 
 export type Reasoning = {
   effort?: ChatGenerationParamsEffort | null | undefined;
@@ -126,14 +130,25 @@ export type ChatGenerationParams = {
 };
 
 /** @internal */
-export const ChatGenerationParamsEffort$inboundSchema: z.ZodNativeEnum<
-  typeof ChatGenerationParamsEffort
-> = z.nativeEnum(ChatGenerationParamsEffort);
+export const ChatGenerationParamsEffort$inboundSchema: z.ZodType<
+  ChatGenerationParamsEffort,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ChatGenerationParamsEffort),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ChatGenerationParamsEffort$outboundSchema: z.ZodNativeEnum<
-  typeof ChatGenerationParamsEffort
-> = ChatGenerationParamsEffort$inboundSchema;
+export const ChatGenerationParamsEffort$outboundSchema: z.ZodType<
+  ChatGenerationParamsEffort,
+  z.ZodTypeDef,
+  ChatGenerationParamsEffort
+> = z.union([
+  z.nativeEnum(ChatGenerationParamsEffort),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -147,14 +162,25 @@ export namespace ChatGenerationParamsEffort$ {
 }
 
 /** @internal */
-export const GenerateSummary$inboundSchema: z.ZodNativeEnum<
-  typeof GenerateSummary
-> = z.nativeEnum(GenerateSummary);
+export const GenerateSummary$inboundSchema: z.ZodType<
+  GenerateSummary,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(GenerateSummary),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const GenerateSummary$outboundSchema: z.ZodNativeEnum<
-  typeof GenerateSummary
-> = GenerateSummary$inboundSchema;
+export const GenerateSummary$outboundSchema: z.ZodType<
+  GenerateSummary,
+  z.ZodTypeDef,
+  GenerateSummary
+> = z.union([
+  z.nativeEnum(GenerateSummary),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -168,12 +194,25 @@ export namespace GenerateSummary$ {
 }
 
 /** @internal */
-export const SummaryEnum$inboundSchema: z.ZodNativeEnum<typeof SummaryEnum> = z
-  .nativeEnum(SummaryEnum);
+export const SummaryEnum$inboundSchema: z.ZodType<
+  SummaryEnum,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(SummaryEnum),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const SummaryEnum$outboundSchema: z.ZodNativeEnum<typeof SummaryEnum> =
-  SummaryEnum$inboundSchema;
+export const SummaryEnum$outboundSchema: z.ZodType<
+  SummaryEnum,
+  z.ZodTypeDef,
+  SummaryEnum
+> = z.union([
+  z.nativeEnum(SummaryEnum),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/chatmessagecontentitemaudio.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 { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
@@ -18,7 +22,7 @@ export const ChatMessageContentItemAudioFormat = {
   Pcm16: "pcm16",
   Pcm24: "pcm24",
 } as const;
-export type ChatMessageContentItemAudioFormat = ClosedEnum<
+export type ChatMessageContentItemAudioFormat = OpenEnum<
   typeof ChatMessageContentItemAudioFormat
 >;
 
@@ -33,14 +37,25 @@ export type ChatMessageContentItemAudio = {
 };
 
 /** @internal */
-export const ChatMessageContentItemAudioFormat$inboundSchema: z.ZodNativeEnum<
-  typeof ChatMessageContentItemAudioFormat
-> = z.nativeEnum(ChatMessageContentItemAudioFormat);
+export const ChatMessageContentItemAudioFormat$inboundSchema: z.ZodType<
+  ChatMessageContentItemAudioFormat,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ChatMessageContentItemAudioFormat),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ChatMessageContentItemAudioFormat$outboundSchema: z.ZodNativeEnum<
-  typeof ChatMessageContentItemAudioFormat
-> = ChatMessageContentItemAudioFormat$inboundSchema;
+export const ChatMessageContentItemAudioFormat$outboundSchema: z.ZodType<
+  ChatMessageContentItemAudioFormat,
+  z.ZodTypeDef,
+  ChatMessageContentItemAudioFormat
+> = z.union([
+  z.nativeEnum(ChatMessageContentItemAudioFormat),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/chatmessagecontentitemimage.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 { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
@@ -14,7 +18,7 @@ export const Detail = {
   Low: "low",
   High: "high",
 } as const;
-export type Detail = ClosedEnum<typeof Detail>;
+export type Detail = OpenEnum<typeof Detail>;
 
 export type ImageUrl = {
   url: string;
@@ -27,12 +31,18 @@ export type ChatMessageContentItemImage = {
 };
 
 /** @internal */
-export const Detail$inboundSchema: z.ZodNativeEnum<typeof Detail> = z
-  .nativeEnum(Detail);
+export const Detail$inboundSchema: z.ZodType<Detail, z.ZodTypeDef, unknown> = z
+  .union([
+    z.nativeEnum(Detail),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const Detail$outboundSchema: z.ZodNativeEnum<typeof Detail> =
-  Detail$inboundSchema;
+export const Detail$outboundSchema: z.ZodType<Detail, z.ZodTypeDef, Detail> = z
+  .union([
+    z.nativeEnum(Detail),
+    z.string().and(z.custom<Unrecognized<string>>()),
+  ]);
 
 /**
  * @internal

package/src/models/chatresponsechoice.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 {
   AssistantMessage,
@@ -28,7 +32,7 @@ export const ChatResponseChoiceFinishReason = {
   ContentFilter: "content_filter",
   Error: "error",
 } as const;
-export type ChatResponseChoiceFinishReason = ClosedEnum<
+export type ChatResponseChoiceFinishReason = OpenEnum<
   typeof ChatResponseChoiceFinishReason
 >;
 
@@ -40,14 +44,25 @@ export type ChatResponseChoice = {
 };
 
 /** @internal */
-export const ChatResponseChoiceFinishReason$inboundSchema: z.ZodNativeEnum<
-  typeof ChatResponseChoiceFinishReason
-> = z.nativeEnum(ChatResponseChoiceFinishReason);
+export const ChatResponseChoiceFinishReason$inboundSchema: z.ZodType<
+  ChatResponseChoiceFinishReason,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ChatResponseChoiceFinishReason),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ChatResponseChoiceFinishReason$outboundSchema: z.ZodNativeEnum<
-  typeof ChatResponseChoiceFinishReason
-> = ChatResponseChoiceFinishReason$inboundSchema;
+export const ChatResponseChoiceFinishReason$outboundSchema: z.ZodType<
+  ChatResponseChoiceFinishReason,
+  z.ZodTypeDef,
+  ChatResponseChoiceFinishReason
+> = z.union([
+  z.nativeEnum(ChatResponseChoiceFinishReason),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/chatstreamingchoice.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 {
   ChatMessageTokenLogprobs,
@@ -28,7 +32,7 @@ export const ChatStreamingChoiceFinishReason = {
   ContentFilter: "content_filter",
   Error: "error",
 } as const;
-export type ChatStreamingChoiceFinishReason = ClosedEnum<
+export type ChatStreamingChoiceFinishReason = OpenEnum<
   typeof ChatStreamingChoiceFinishReason
 >;
 
@@ -40,14 +44,25 @@ export type ChatStreamingChoice = {
 };
 
 /** @internal */
-export const ChatStreamingChoiceFinishReason$inboundSchema: z.ZodNativeEnum<
-  typeof ChatStreamingChoiceFinishReason
-> = z.nativeEnum(ChatStreamingChoiceFinishReason);
+export const ChatStreamingChoiceFinishReason$inboundSchema: z.ZodType<
+  ChatStreamingChoiceFinishReason,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ChatStreamingChoiceFinishReason),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ChatStreamingChoiceFinishReason$outboundSchema: z.ZodNativeEnum<
-  typeof ChatStreamingChoiceFinishReason
-> = ChatStreamingChoiceFinishReason$inboundSchema;
+export const ChatStreamingChoiceFinishReason$outboundSchema: z.ZodType<
+  ChatStreamingChoiceFinishReason,
+  z.ZodTypeDef,
+  ChatStreamingChoiceFinishReason
+> = z.union([
+  z.nativeEnum(ChatStreamingChoiceFinishReason),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/completionfinishreason.ts

@@ -3,24 +3,39 @@
  */
 
 import * as z from "zod";
-import { ClosedEnum } from "../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 
 export const CompletionFinishReason = {
   Stop: "stop",
   Length: "length",
   ContentFilter: "content_filter",
 } as const;
-export type CompletionFinishReason = ClosedEnum<typeof CompletionFinishReason>;
+export type CompletionFinishReason = OpenEnum<typeof CompletionFinishReason>;
 
 /** @internal */
-export const CompletionFinishReason$inboundSchema: z.ZodNativeEnum<
-  typeof CompletionFinishReason
-> = z.nativeEnum(CompletionFinishReason);
+export const CompletionFinishReason$inboundSchema: z.ZodType<
+  CompletionFinishReason,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(CompletionFinishReason),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const CompletionFinishReason$outboundSchema: z.ZodNativeEnum<
-  typeof CompletionFinishReason
-> = CompletionFinishReason$inboundSchema;
+export const CompletionFinishReason$outboundSchema: z.ZodType<
+  CompletionFinishReason,
+  z.ZodTypeDef,
+  CompletionFinishReason
+> = z.union([
+  z.nativeEnum(CompletionFinishReason),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal