@meetkai/mka1 0.54.7 → 0.54.8

package/src/models/components/responsestreamingevent.ts

@@ -4,6 +4,8 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
+import * as discriminatedUnionTypes from "../../types/discriminatedUnion.js";
+import { discriminatedUnion } from "../../types/discriminatedUnion.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -462,80 +464,128 @@ export type ResponseStreamingEvent =
   | ResponseCustomToolCallInputDeltaEvent
   | ResponseCustomToolCallInputDoneEvent
   | ResponseOutputTextAnnotationAddedEvent
-  | ErrorEvent;
+  | ErrorEvent
+  | discriminatedUnionTypes.Unknown<"type">;
 
 /** @internal */
 export const ResponseStreamingEvent$inboundSchema: z.ZodType<
   ResponseStreamingEvent,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  ResponseCreatedEvent$inboundSchema,
-  ResponseInProgressEvent$inboundSchema,
-  ResponseCompletedEvent$inboundSchema,
-  ResponseFailedEvent$inboundSchema,
-  ResponseIncompleteEvent$inboundSchema,
-  ResponseQueuedEvent$inboundSchema,
-  ResponseCancelledEvent$inboundSchema,
-  ResponseOutputItemAddedEvent$inboundSchema,
-  ResponseOutputItemDoneEvent$inboundSchema,
-  ResponseContentPartAddedEvent$inboundSchema,
-  ResponseContentPartDoneEvent$inboundSchema,
-  ResponseOutputTextDeltaEvent$inboundSchema,
-  ResponseOutputTextDoneEvent$inboundSchema,
-  ResponseRefusalDeltaEvent$inboundSchema,
-  ResponseRefusalDoneEvent$inboundSchema,
-  ResponseFunctionCallArgumentsDeltaEvent$inboundSchema,
-  ResponseFunctionCallArgumentsDoneEvent$inboundSchema,
-  ResponseFileSearchCallInProgressEvent$inboundSchema,
-  ResponseFileSearchCallSearchingEvent$inboundSchema,
-  ResponseFileSearchCallCompletedEvent$inboundSchema,
-  ResponseWebSearchCallInProgressEvent$inboundSchema,
-  ResponseWebSearchCallSearchingEvent$inboundSchema,
-  ResponseWebSearchCallCompletedEvent$inboundSchema,
-  ResponseHistoryCallInProgressEvent$inboundSchema,
-  ResponseHistoryCallSearchingEvent$inboundSchema,
-  ResponseHistoryCallCompletedEvent$inboundSchema,
-  ResponseSleepCallInProgressEvent$inboundSchema,
-  ResponseSleepCallSleepingEvent$inboundSchema,
-  ResponseSleepCallCompletedEvent$inboundSchema,
-  ResponseToolSearchCallInProgressEvent$inboundSchema,
-  ResponseToolSearchCallSearchingEvent$inboundSchema,
-  ResponseToolSearchCallCompletedEvent$inboundSchema,
-  ResponseReasoningSummaryPartAddedEvent$inboundSchema,
-  ResponseReasoningSummaryPartDoneEvent$inboundSchema,
-  ResponseReasoningSummaryTextDeltaEvent$inboundSchema,
-  ResponseReasoningSummaryTextDoneEvent$inboundSchema,
-  ResponseReasoningTextDeltaEvent$inboundSchema,
-  ResponseReasoningTextDoneEvent$inboundSchema,
-  ResponseImageGenerationCallInProgressEvent$inboundSchema,
-  ResponseImageGenerationCallGeneratingEvent$inboundSchema,
-  ResponseImageGenerationCallCompletedEvent$inboundSchema,
-  ResponseImageGenerationCallPartialImageEvent$inboundSchema,
-  ResponseMCPCallArgumentsDeltaEvent$inboundSchema,
-  ResponseMCPCallArgumentsDoneEvent$inboundSchema,
-  ResponseMCPCallInProgressEvent$inboundSchema,
-  ResponseMCPCallCompletedEvent$inboundSchema,
-  ResponseMCPCallFailedEvent$inboundSchema,
-  ResponseMCPListToolsInProgressEvent$inboundSchema,
-  ResponseMCPListToolsCompletedEvent$inboundSchema,
-  ResponseMCPListToolsFailedEvent$inboundSchema,
-  ResponseReadFileCallInProgressEvent$inboundSchema,
-  ResponseReadFileCallReadingEvent$inboundSchema,
-  ResponseReadFileCallCompletedEvent$inboundSchema,
-  ResponseCodeInterpreterCallInProgressEvent$inboundSchema,
-  ResponseCodeInterpreterCallInterpretingEvent$inboundSchema,
-  ResponseCodeInterpreterCallCompletedEvent$inboundSchema,
-  ResponseCodeInterpreterCallCodeDeltaEvent$inboundSchema,
-  ResponseCodeInterpreterCallCodeDoneEvent$inboundSchema,
-  ResponseShellCallInProgressEvent$inboundSchema,
-  ResponseShellCallExecutingEvent$inboundSchema,
-  ResponseShellCallCompletedEvent$inboundSchema,
-  ResponseCustomToolCallInputDeltaEvent$inboundSchema,
-  ResponseCustomToolCallInputDoneEvent$inboundSchema,
-  ResponseOutputTextAnnotationAddedEvent$inboundSchema,
-  ErrorEvent$inboundSchema,
-]);
+> = discriminatedUnion("type", {
+  ["response.created"]: ResponseCreatedEvent$inboundSchema,
+  ["response.in_progress"]: ResponseInProgressEvent$inboundSchema,
+  ["response.completed"]: ResponseCompletedEvent$inboundSchema,
+  ["response.failed"]: ResponseFailedEvent$inboundSchema,
+  ["response.incomplete"]: ResponseIncompleteEvent$inboundSchema,
+  ["response.queued"]: ResponseQueuedEvent$inboundSchema,
+  ["response.cancelled"]: ResponseCancelledEvent$inboundSchema,
+  ["response.output_item.added"]: ResponseOutputItemAddedEvent$inboundSchema,
+  ["response.output_item.done"]: ResponseOutputItemDoneEvent$inboundSchema,
+  ["response.content_part.added"]: ResponseContentPartAddedEvent$inboundSchema,
+  ["response.content_part.done"]: ResponseContentPartDoneEvent$inboundSchema,
+  ["response.output_text.delta"]: ResponseOutputTextDeltaEvent$inboundSchema,
+  ["response.output_text.done"]: ResponseOutputTextDoneEvent$inboundSchema,
+  ["response.refusal.delta"]: ResponseRefusalDeltaEvent$inboundSchema,
+  ["response.refusal.done"]: ResponseRefusalDoneEvent$inboundSchema,
+  ["response.function_call_arguments.delta"]:
+    ResponseFunctionCallArgumentsDeltaEvent$inboundSchema,
+  ["response.function_call_arguments.done"]:
+    ResponseFunctionCallArgumentsDoneEvent$inboundSchema,
+  ["response.file_search_call.in_progress"]:
+    ResponseFileSearchCallInProgressEvent$inboundSchema,
+  ["response.file_search_call.searching"]:
+    ResponseFileSearchCallSearchingEvent$inboundSchema,
+  ["response.file_search_call.completed"]:
+    ResponseFileSearchCallCompletedEvent$inboundSchema,
+  ["response.web_search_call.in_progress"]:
+    ResponseWebSearchCallInProgressEvent$inboundSchema,
+  ["response.web_search_call.searching"]:
+    ResponseWebSearchCallSearchingEvent$inboundSchema,
+  ["response.web_search_call.completed"]:
+    ResponseWebSearchCallCompletedEvent$inboundSchema,
+  ["response.history_call.in_progress"]:
+    ResponseHistoryCallInProgressEvent$inboundSchema,
+  ["response.history_call.searching"]:
+    ResponseHistoryCallSearchingEvent$inboundSchema,
+  ["response.history_call.completed"]:
+    ResponseHistoryCallCompletedEvent$inboundSchema,
+  ["response.sleep_call.in_progress"]:
+    ResponseSleepCallInProgressEvent$inboundSchema,
+  ["response.sleep_call.sleeping"]:
+    ResponseSleepCallSleepingEvent$inboundSchema,
+  ["response.sleep_call.completed"]:
+    ResponseSleepCallCompletedEvent$inboundSchema,
+  ["response.tool_search_call.in_progress"]:
+    ResponseToolSearchCallInProgressEvent$inboundSchema,
+  ["response.tool_search_call.searching"]:
+    ResponseToolSearchCallSearchingEvent$inboundSchema,
+  ["response.tool_search_call.completed"]:
+    ResponseToolSearchCallCompletedEvent$inboundSchema,
+  ["response.reasoning_summary_part.added"]:
+    ResponseReasoningSummaryPartAddedEvent$inboundSchema,
+  ["response.reasoning_summary_part.done"]:
+    ResponseReasoningSummaryPartDoneEvent$inboundSchema,
+  ["response.reasoning_summary_text.delta"]:
+    ResponseReasoningSummaryTextDeltaEvent$inboundSchema,
+  ["response.reasoning_summary_text.done"]:
+    ResponseReasoningSummaryTextDoneEvent$inboundSchema,
+  ["response.reasoning_text.delta"]:
+    ResponseReasoningTextDeltaEvent$inboundSchema,
+  ["response.reasoning_text.done"]:
+    ResponseReasoningTextDoneEvent$inboundSchema,
+  ["response.image_generation_call.in_progress"]:
+    ResponseImageGenerationCallInProgressEvent$inboundSchema,
+  ["response.image_generation_call.generating"]:
+    ResponseImageGenerationCallGeneratingEvent$inboundSchema,
+  ["response.image_generation_call.completed"]:
+    ResponseImageGenerationCallCompletedEvent$inboundSchema,
+  ["response.image_generation_call.partial_image"]:
+    ResponseImageGenerationCallPartialImageEvent$inboundSchema,
+  ["response.mcp_call_arguments.delta"]:
+    ResponseMCPCallArgumentsDeltaEvent$inboundSchema,
+  ["response.mcp_call_arguments.done"]:
+    ResponseMCPCallArgumentsDoneEvent$inboundSchema,
+  ["response.mcp_call.in_progress"]:
+    ResponseMCPCallInProgressEvent$inboundSchema,
+  ["response.mcp_call.completed"]: ResponseMCPCallCompletedEvent$inboundSchema,
+  ["response.mcp_call.failed"]: ResponseMCPCallFailedEvent$inboundSchema,
+  ["response.mcp_list_tools.in_progress"]:
+    ResponseMCPListToolsInProgressEvent$inboundSchema,
+  ["response.mcp_list_tools.completed"]:
+    ResponseMCPListToolsCompletedEvent$inboundSchema,
+  ["response.mcp_list_tools.failed"]:
+    ResponseMCPListToolsFailedEvent$inboundSchema,
+  ["response.read_file_call.in_progress"]:
+    ResponseReadFileCallInProgressEvent$inboundSchema,
+  ["response.read_file_call.reading"]:
+    ResponseReadFileCallReadingEvent$inboundSchema,
+  ["response.read_file_call.completed"]:
+    ResponseReadFileCallCompletedEvent$inboundSchema,
+  ["response.code_interpreter_call.in_progress"]:
+    ResponseCodeInterpreterCallInProgressEvent$inboundSchema,
+  ["response.code_interpreter_call.interpreting"]:
+    ResponseCodeInterpreterCallInterpretingEvent$inboundSchema,
+  ["response.code_interpreter_call.completed"]:
+    ResponseCodeInterpreterCallCompletedEvent$inboundSchema,
+  ["response.code_interpreter_call_code.delta"]:
+    ResponseCodeInterpreterCallCodeDeltaEvent$inboundSchema,
+  ["response.code_interpreter_call_code.done"]:
+    ResponseCodeInterpreterCallCodeDoneEvent$inboundSchema,
+  ["response.shell_call.in_progress"]:
+    ResponseShellCallInProgressEvent$inboundSchema,
+  ["response.shell_call.executing"]:
+    ResponseShellCallExecutingEvent$inboundSchema,
+  ["response.shell_call.completed"]:
+    ResponseShellCallCompletedEvent$inboundSchema,
+  ["response.custom_tool_call_input.delta"]:
+    ResponseCustomToolCallInputDeltaEvent$inboundSchema,
+  ["response.custom_tool_call_input.done"]:
+    ResponseCustomToolCallInputDoneEvent$inboundSchema,
+  ["response.output_text.annotation.added"]:
+    ResponseOutputTextAnnotationAddedEvent$inboundSchema,
+  error: ErrorEvent$inboundSchema,
+});
 /** @internal */
 export type ResponseStreamingEvent$Outbound =
   | ResponseCreatedEvent$Outbound

package/src/models/components/shellenvironment.ts

@@ -4,6 +4,8 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
+import * as discriminatedUnionTypes from "../../types/discriminatedUnion.js";
+import { discriminatedUnion } from "../../types/discriminatedUnion.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -21,17 +23,18 @@ import {
 
 export type ShellEnvironment =
   | ShellEnvironmentContainerAuto
-  | ShellEnvironmentContainerReference;
+  | ShellEnvironmentContainerReference
+  | discriminatedUnionTypes.Unknown<"type">;
 
 /** @internal */
 export const ShellEnvironment$inboundSchema: z.ZodType<
   ShellEnvironment,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  ShellEnvironmentContainerAuto$inboundSchema,
-  ShellEnvironmentContainerReference$inboundSchema,
-]);
+> = discriminatedUnion("type", {
+  container_auto: ShellEnvironmentContainerAuto$inboundSchema,
+  container_reference: ShellEnvironmentContainerReference$inboundSchema,
+});
 /** @internal */
 export type ShellEnvironment$Outbound =
   | ShellEnvironmentContainerAuto$Outbound

package/src/models/components/skillentry.ts

@@ -4,6 +4,8 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
+import * as discriminatedUnionTypes from "../../types/discriminatedUnion.js";
+import { discriminatedUnion } from "../../types/discriminatedUnion.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -19,17 +21,20 @@ import {
   SkillReference$outboundSchema,
 } from "./skillreference.js";
 
-export type SkillEntry = SkillReference | PreconfiguredSkillReference;
+export type SkillEntry =
+  | SkillReference
+  | PreconfiguredSkillReference
+  | discriminatedUnionTypes.Unknown<"type">;
 
 /** @internal */
 export const SkillEntry$inboundSchema: z.ZodType<
   SkillEntry,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  SkillReference$inboundSchema,
-  PreconfiguredSkillReference$inboundSchema,
-]);
+> = discriminatedUnion("type", {
+  skill_reference: SkillReference$inboundSchema,
+  preconfigured: PreconfiguredSkillReference$inboundSchema,
+});
 /** @internal */
 export type SkillEntry$Outbound =
   | SkillReference$Outbound

package/src/models/components/tooldefinition.ts

@@ -5,6 +5,8 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
+import * as discriminatedUnionTypes from "../../types/discriminatedUnion.js";
+import { discriminatedUnion } from "../../types/discriminatedUnion.js";
 import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
@@ -83,11 +85,18 @@ export type Environment1 = {
   memoryStores?: Array<MemoryStores> | undefined;
 };
 
-export type Environment = Environment1 | Environment2;
+export type Environment =
+  | Environment1
+  | Environment2
+  | discriminatedUnionTypes.Unknown<"type">;
 
 export type Seven = {
   type: ToolDefinition7Type;
-  environment?: Environment1 | Environment2 | undefined;
+  environment?:
+    | Environment1
+    | Environment2
+    | discriminatedUnionTypes.Unknown<"type">
+    | undefined;
 };
 
 export const ToolDefinition6Type = {
@@ -124,7 +133,8 @@ export type ToolDefinition4Filters =
   | (FileSearchComparisonFilter & { type: "lt" })
   | (FileSearchComparisonFilter & { type: "lte" })
   | (FileSearchCompoundFilter & { type: "and" })
-  | (FileSearchCompoundFilter & { type: "or" });
+  | (FileSearchCompoundFilter & { type: "or" })
+  | discriminatedUnionTypes.Unknown<"type">;
 
 export type ToolDefinitionRankingOptions = {
   ranker?: string | undefined;
@@ -143,6 +153,7 @@ export type ToolDefinition4 = {
     | (FileSearchComparisonFilter & { type: "lte" })
     | (FileSearchCompoundFilter & { type: "and" })
     | (FileSearchCompoundFilter & { type: "or" })
+    | discriminatedUnionTypes.Unknown<"type">
     | undefined;
   maxNumResults?: number | undefined;
   rankingOptions?: ToolDefinitionRankingOptions | undefined;
@@ -549,10 +560,10 @@ export const Environment$inboundSchema: z.ZodType<
   Environment,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  z.lazy(() => Environment1$inboundSchema),
-  z.lazy(() => Environment2$inboundSchema),
-]);
+> = discriminatedUnion("type", {
+  container_auto: z.lazy(() => Environment1$inboundSchema),
+  container_reference: z.lazy(() => Environment2$inboundSchema),
+});
 /** @internal */
 export type Environment$Outbound =
   | Environment1$Outbound
@@ -585,10 +596,10 @@ export function environmentFromJSON(
 export const Seven$inboundSchema: z.ZodType<Seven, z.ZodTypeDef, unknown> = z
   .object({
     type: ToolDefinition7Type$inboundSchema,
-    environment: z.union([
-      z.lazy(() => Environment1$inboundSchema),
-      z.lazy(() => Environment2$inboundSchema),
-    ]).optional(),
+    environment: discriminatedUnion("type", {
+      container_auto: z.lazy(() => Environment1$inboundSchema),
+      container_reference: z.lazy(() => Environment2$inboundSchema),
+    }).optional(),
   });
 /** @internal */
 export type Seven$Outbound = {
@@ -728,32 +739,32 @@ export const ToolDefinition4Filters$inboundSchema: z.ZodType<
   ToolDefinition4Filters,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  FileSearchComparisonFilter$inboundSchema.and(
+> = discriminatedUnion("type", {
+  eq: FileSearchComparisonFilter$inboundSchema.and(
     z.object({ type: z.literal("eq") }),
   ),
-  FileSearchComparisonFilter$inboundSchema.and(
+  ne: FileSearchComparisonFilter$inboundSchema.and(
     z.object({ type: z.literal("ne") }),
   ),
-  FileSearchComparisonFilter$inboundSchema.and(
+  gt: FileSearchComparisonFilter$inboundSchema.and(
     z.object({ type: z.literal("gt") }),
   ),
-  FileSearchComparisonFilter$inboundSchema.and(
+  gte: FileSearchComparisonFilter$inboundSchema.and(
     z.object({ type: z.literal("gte") }),
   ),
-  FileSearchComparisonFilter$inboundSchema.and(
+  lt: FileSearchComparisonFilter$inboundSchema.and(
     z.object({ type: z.literal("lt") }),
   ),
-  FileSearchComparisonFilter$inboundSchema.and(
+  lte: FileSearchComparisonFilter$inboundSchema.and(
     z.object({ type: z.literal("lte") }),
   ),
-  FileSearchCompoundFilter$inboundSchema.and(
+  and: FileSearchCompoundFilter$inboundSchema.and(
     z.object({ type: z.literal("and") }),
   ),
-  FileSearchCompoundFilter$inboundSchema.and(
+  or: FileSearchCompoundFilter$inboundSchema.and(
     z.object({ type: z.literal("or") }),
   ),
-]);
+});
 /** @internal */
 export type ToolDefinition4Filters$Outbound =
   | (FileSearchComparisonFilter$Outbound & { type: "eq" })
@@ -874,32 +885,32 @@ export const ToolDefinition4$inboundSchema: z.ZodType<
 > = z.object({
   type: ToolDefinition4Type$inboundSchema,
   vector_store_ids: z.array(z.string()),
-  filters: z.union([
-    FileSearchComparisonFilter$inboundSchema.and(
+  filters: discriminatedUnion("type", {
+    eq: FileSearchComparisonFilter$inboundSchema.and(
       z.object({ type: z.literal("eq") }),
     ),
-    FileSearchComparisonFilter$inboundSchema.and(
+    ne: FileSearchComparisonFilter$inboundSchema.and(
       z.object({ type: z.literal("ne") }),
     ),
-    FileSearchComparisonFilter$inboundSchema.and(
+    gt: FileSearchComparisonFilter$inboundSchema.and(
       z.object({ type: z.literal("gt") }),
     ),
-    FileSearchComparisonFilter$inboundSchema.and(
+    gte: FileSearchComparisonFilter$inboundSchema.and(
       z.object({ type: z.literal("gte") }),
     ),
-    FileSearchComparisonFilter$inboundSchema.and(
+    lt: FileSearchComparisonFilter$inboundSchema.and(
       z.object({ type: z.literal("lt") }),
     ),
-    FileSearchComparisonFilter$inboundSchema.and(
+    lte: FileSearchComparisonFilter$inboundSchema.and(
       z.object({ type: z.literal("lte") }),
     ),
-    FileSearchCompoundFilter$inboundSchema.and(
+    and: FileSearchCompoundFilter$inboundSchema.and(
       z.object({ type: z.literal("and") }),
     ),
-    FileSearchCompoundFilter$inboundSchema.and(
+    or: FileSearchCompoundFilter$inboundSchema.and(
       z.object({ type: z.literal("or") }),
     ),
-  ]).optional(),
+  }).optional(),
   max_num_results: z.number().int().optional(),
   ranking_options: z.lazy(() => ToolDefinitionRankingOptions$inboundSchema)
     .optional(),

package/src/models/components/websearchaction.ts

@@ -4,6 +4,8 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
+import * as discriminatedUnionTypes from "../../types/discriminatedUnion.js";
+import { discriminatedUnion } from "../../types/discriminatedUnion.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -25,18 +27,22 @@ import {
   SearchAction$outboundSchema,
 } from "./searchaction.js";
 
-export type WebSearchAction = SearchAction | OpenPageAction | FindAction;
+export type WebSearchAction =
+  | SearchAction
+  | OpenPageAction
+  | FindAction
+  | discriminatedUnionTypes.Unknown<"type">;
 
 /** @internal */
 export const WebSearchAction$inboundSchema: z.ZodType<
   WebSearchAction,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  SearchAction$inboundSchema,
-  OpenPageAction$inboundSchema,
-  FindAction$inboundSchema,
-]);
+> = discriminatedUnion("type", {
+  search: SearchAction$inboundSchema,
+  open_page: OpenPageAction$inboundSchema,
+  find: FindAction$inboundSchema,
+});
 /** @internal */
 export type WebSearchAction$Outbound =
   | SearchAction$Outbound

package/src/models/operations/createchatcompletionstream.ts

@@ -5,6 +5,8 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
+import * as discriminatedUnionTypes from "../../types/discriminatedUnion.js";
+import { discriminatedUnion } from "../../types/discriminatedUnion.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import * as components from "../components/index.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
@@ -45,7 +47,11 @@ export type One = {
 /**
  * OK
  */
-export type CreateChatCompletionStreamResponseBody = One | Two | Three;
+export type CreateChatCompletionStreamResponseBody =
+  | One
+  | Two
+  | Three
+  | discriminatedUnionTypes.Unknown<"event">;
 
 /** @internal */
 export const CreateChatCompletionStreamRequest$inboundSchema: z.ZodType<
@@ -234,11 +240,11 @@ export const CreateChatCompletionStreamResponseBody$inboundSchema: z.ZodType<
   CreateChatCompletionStreamResponseBody,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  z.lazy(() => One$inboundSchema),
-  z.lazy(() => Two$inboundSchema),
-  z.lazy(() => Three$inboundSchema),
-]);
+> = discriminatedUnion("event", {
+  message: z.lazy(() => One$inboundSchema),
+  done: z.lazy(() => Two$inboundSchema),
+  error: z.lazy(() => Three$inboundSchema),
+});
 /** @internal */
 export type CreateChatCompletionStreamResponseBody$Outbound =
   | One$Outbound

package/src/models/operations/uploadfile.ts

@@ -33,7 +33,7 @@ export type Purpose = ClosedEnum<typeof Purpose>;
 
 export type UploadFileRequestBody = {
   /**
-   * The file to upload
+   * The file to upload. Multipart file parts must include a nonblank filename; the lowercase WHATWG placeholder filename "blob" is treated as missing.
    */
   file: FileT | Blob;
   /**

package/src/types/discriminatedUnion.ts

@@ -0,0 +1,96 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { startCountingUnrecognized } from "./unrecognized.js";
+
+const UNKNOWN = Symbol("UNKNOWN");
+
+export type Unknown<Discriminator extends string, UnknownValue = "UNKNOWN"> =
+  & {
+    [K in Discriminator]: UnknownValue;
+  }
+  & {
+    raw: unknown;
+    isUnknown: true;
+  };
+
+export function isUnknown<Discriminator extends string>(
+  value: unknown,
+): value is Unknown<Discriminator> {
+  return typeof value === "object" && value !== null && UNKNOWN in value;
+}
+
+/**
+ * Forward-compatible discriminated union parser.
+ *
+ * If the input does not match one of the predefined options, it will be
+ * captured and available as `{ raw: <original input>, [discriminator]: "UNKNOWN", isUnknown: true }`.
+ *
+ * @param inputPropertyName - The discriminator property name in the input payload
+ * @param options - Map of discriminator values to their corresponding schemas
+ * @param opts - Optional configuration object
+ * @param opts.unknownValue - The value to use for the discriminator when the input is unknown (default: "UNKNOWN")
+ * @param opts.outputPropertyName - Output property name if the sanitized (camelCase) property name differs from inputPropertyName
+ */
+export function discriminatedUnion<
+  InputDiscriminator extends string,
+  TOptions extends Readonly<Record<string, z.ZodType>>,
+  UnknownValue extends string = "UNKNOWN",
+  OutputDiscriminator extends string = InputDiscriminator,
+>(
+  inputPropertyName: InputDiscriminator,
+  options: TOptions,
+  opts: {
+    unknownValue?: UnknownValue;
+    outputPropertyName?: OutputDiscriminator;
+  } = {},
+): z.ZodType<
+  | z.output<TOptions[keyof TOptions]>
+  | Unknown<OutputDiscriminator, UnknownValue>,
+  z.ZodTypeDef,
+  unknown
+> {
+  const { unknownValue = "UNKNOWN" as UnknownValue, outputPropertyName } = opts;
+  return z.unknown().transform((input) => {
+    const fallback = Object.defineProperties(
+      {
+        raw: input,
+        [outputPropertyName ?? inputPropertyName]: unknownValue,
+        isUnknown: true as const,
+      },
+      { [UNKNOWN]: { value: true, enumerable: false, configurable: false } },
+    );
+
+    const isObject = typeof input === "object" && input !== null;
+    if (!isObject) return fallback;
+
+    const discriminator = input[inputPropertyName as keyof typeof input];
+    if (typeof discriminator !== "string") return fallback;
+    if (!(discriminator in options)) return fallback;
+
+    const schema = options[discriminator];
+    if (!schema) return fallback;
+
+    // Start counters before parsing to track nested unrecognized/zeroDefault values
+    const unrecognizedCtr = startCountingUnrecognized();
+
+    const result = schema.safeParse(input);
+    if (!result.success) {
+      // Parse failed - don't propagate any counts from the failed attempt
+      unrecognizedCtr.end(0);
+
+      return fallback;
+    }
+
+    // Parse succeeded - propagate the actual counts
+    unrecognizedCtr.end();
+
+    if (outputPropertyName) {
+      (result.data as any)[outputPropertyName] = discriminator;
+    }
+
+    return result.data;
+  }) as any;
+}