@meetkai/mka1 0.54.6 → 0.54.8

package/src/models/components/responsecontentpartdoneevent.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 { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -29,7 +31,8 @@ import {
 export type ResponseContentPartDoneEventPart =
   | (OutputText & { type: "output_text" })
   | (Refusal & { type: "refusal" })
-  | (ReasoningText & { type: "reasoning_text" });
+  | (ReasoningText & { type: "reasoning_text" })
+  | discriminatedUnionTypes.Unknown<"type">;
 
 export type ResponseContentPartDoneEvent = {
   type: "response.content_part.done";
@@ -40,7 +43,8 @@ export type ResponseContentPartDoneEvent = {
   part:
     | (OutputText & { type: "output_text" })
     | (Refusal & { type: "refusal" })
-    | (ReasoningText & { type: "reasoning_text" });
+    | (ReasoningText & { type: "reasoning_text" })
+    | discriminatedUnionTypes.Unknown<"type">;
 };
 
 /** @internal */
@@ -48,13 +52,15 @@ export const ResponseContentPartDoneEventPart$inboundSchema: z.ZodType<
   ResponseContentPartDoneEventPart,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  OutputText$inboundSchema.and(z.object({ type: z.literal("output_text") })),
-  Refusal$inboundSchema.and(z.object({ type: z.literal("refusal") })),
-  ReasoningText$inboundSchema.and(
+> = discriminatedUnion("type", {
+  output_text: OutputText$inboundSchema.and(
+    z.object({ type: z.literal("output_text") }),
+  ),
+  refusal: Refusal$inboundSchema.and(z.object({ type: z.literal("refusal") })),
+  reasoning_text: ReasoningText$inboundSchema.and(
     z.object({ type: z.literal("reasoning_text") }),
   ),
-]);
+});
 /** @internal */
 export type ResponseContentPartDoneEventPart$Outbound =
   | (OutputText$Outbound & { type: "output_text" })
@@ -104,13 +110,17 @@ export const ResponseContentPartDoneEvent$inboundSchema: z.ZodType<
   item_id: z.string(),
   output_index: z.number().int(),
   content_index: z.number().int(),
-  part: z.union([
-    OutputText$inboundSchema.and(z.object({ type: z.literal("output_text") })),
-    Refusal$inboundSchema.and(z.object({ type: z.literal("refusal") })),
-    ReasoningText$inboundSchema.and(
+  part: discriminatedUnion("type", {
+    output_text: OutputText$inboundSchema.and(
+      z.object({ type: z.literal("output_text") }),
+    ),
+    refusal: Refusal$inboundSchema.and(
+      z.object({ type: z.literal("refusal") }),
+    ),
+    reasoning_text: ReasoningText$inboundSchema.and(
       z.object({ type: z.literal("reasoning_text") }),
     ),
-  ]),
+  }),
 }).transform((v) => {
   return remap$(v, {
     "sequence_number": "sequenceNumber",

package/src/models/components/responseformat.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 {
@@ -28,18 +30,19 @@ import {
 export type ResponseFormat =
   | TextResponseFormat
   | JSONSchemaResponseFormat
-  | JSONObjectResponseFormat;
+  | JSONObjectResponseFormat
+  | discriminatedUnionTypes.Unknown<"type">;
 
 /** @internal */
 export const ResponseFormat$inboundSchema: z.ZodType<
   ResponseFormat,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  TextResponseFormat$inboundSchema,
-  JSONSchemaResponseFormat$inboundSchema,
-  JSONObjectResponseFormat$inboundSchema,
-]);
+> = discriminatedUnion("type", {
+  text: TextResponseFormat$inboundSchema,
+  json_schema: JSONSchemaResponseFormat$inboundSchema,
+  json_object: JSONObjectResponseFormat$inboundSchema,
+});
 /** @internal */
 export type ResponseFormat$Outbound =
   | TextResponseFormat$Outbound

package/src/models/components/responseobject.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";
@@ -197,7 +199,8 @@ export type FiltersFilters =
   | (ComparisonFilter & { type: "lt" })
   | (ComparisonFilter & { type: "lte" })
   | (ResponseObjectFilters2 & { type: "and" })
-  | (ResponseObjectFilters2 & { type: "or" });
+  | (ResponseObjectFilters2 & { type: "or" })
+  | discriminatedUnionTypes.Unknown<"type">;
 
 export type Filters2 = {
   type: FiltersType;
@@ -210,6 +213,7 @@ export type Filters2 = {
     | (ComparisonFilter & { type: "lte" })
     | (ResponseObjectFilters2 & { type: "and" })
     | (ResponseObjectFilters2 & { type: "or" })
+    | discriminatedUnionTypes.Unknown<"type">
   >;
 };
 
@@ -221,7 +225,8 @@ export type ToolsFilters =
   | (ComparisonFilter & { type: "lt" })
   | (ComparisonFilter & { type: "lte" })
   | (Filters2 & { type: "and" })
-  | (Filters2 & { type: "or" });
+  | (Filters2 & { type: "or" })
+  | discriminatedUnionTypes.Unknown<"type">;
 
 /**
  * File search tool definition: Configures semantic search over one or more vector stores, with optional filters, ranking options, and result limits.
@@ -238,6 +243,7 @@ export type ToolsFileSearchToolDefinition = {
     | (ComparisonFilter & { type: "lte" })
     | (Filters2 & { type: "and" })
     | (Filters2 & { type: "or" })
+    | discriminatedUnionTypes.Unknown<"type">
     | undefined;
   maxNumResults?: number | undefined;
   rankingOptions?: RankingOptions | undefined;
@@ -426,20 +432,20 @@ export const FiltersFilters$inboundSchema: z.ZodType<
   FiltersFilters,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("eq") })),
-  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("ne") })),
-  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gt") })),
-  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gte") })),
-  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lt") })),
-  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lte") })),
-  z.lazy(() => ResponseObjectFilters2$inboundSchema).and(
+> = discriminatedUnion("type", {
+  eq: ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("eq") })),
+  ne: ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("ne") })),
+  gt: ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gt") })),
+  gte: ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gte") })),
+  lt: ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lt") })),
+  lte: ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lte") })),
+  and: z.lazy(() => ResponseObjectFilters2$inboundSchema).and(
     z.object({ type: z.literal("and") }),
   ),
-  z.lazy(() => ResponseObjectFilters2$inboundSchema).and(
+  or: z.lazy(() => ResponseObjectFilters2$inboundSchema).and(
     z.object({ type: z.literal("or") }),
   ),
-]);
+});
 /** @internal */
 export type FiltersFilters$Outbound =
   | (ComparisonFilter$Outbound & { type: "eq" })
@@ -491,22 +497,24 @@ export const Filters2$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   type: FiltersType$inboundSchema,
-  filters: z.array(
-    z.union([
-      ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("eq") })),
-      ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("ne") })),
-      ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gt") })),
-      ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gte") })),
-      ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lt") })),
-      ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lte") })),
-      z.lazy(() => ResponseObjectFilters2$inboundSchema).and(
-        z.object({ type: z.literal("and") }),
-      ),
-      z.lazy(() => ResponseObjectFilters2$inboundSchema).and(
-        z.object({ type: z.literal("or") }),
-      ),
-    ]),
-  ),
+  filters: z.array(discriminatedUnion("type", {
+    eq: ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("eq") })),
+    ne: ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("ne") })),
+    gt: ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gt") })),
+    gte: ComparisonFilter$inboundSchema.and(
+      z.object({ type: z.literal("gte") }),
+    ),
+    lt: ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lt") })),
+    lte: ComparisonFilter$inboundSchema.and(
+      z.object({ type: z.literal("lte") }),
+    ),
+    and: z.lazy(() => ResponseObjectFilters2$inboundSchema).and(
+      z.object({ type: z.literal("and") }),
+    ),
+    or: z.lazy(() => ResponseObjectFilters2$inboundSchema).and(
+      z.object({ type: z.literal("or") }),
+    ),
+  })),
 });
 /** @internal */
 export type Filters2$Outbound = {
@@ -566,18 +574,20 @@ export const ToolsFilters$inboundSchema: z.ZodType<
   ToolsFilters,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("eq") })),
-  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("ne") })),
-  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gt") })),
-  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gte") })),
-  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lt") })),
-  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lte") })),
-  z.lazy(() => Filters2$inboundSchema).and(
+> = discriminatedUnion("type", {
+  eq: ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("eq") })),
+  ne: ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("ne") })),
+  gt: ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gt") })),
+  gte: ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gte") })),
+  lt: ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lt") })),
+  lte: ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lte") })),
+  and: z.lazy(() => Filters2$inboundSchema).and(
     z.object({ type: z.literal("and") }),
   ),
-  z.lazy(() => Filters2$inboundSchema).and(z.object({ type: z.literal("or") })),
-]);
+  or: z.lazy(() => Filters2$inboundSchema).and(
+    z.object({ type: z.literal("or") }),
+  ),
+});
 /** @internal */
 export type ToolsFilters$Outbound =
   | (ComparisonFilter$Outbound & { type: "eq" })
@@ -630,20 +640,24 @@ export const ToolsFileSearchToolDefinition$inboundSchema: z.ZodType<
 > = z.object({
   type: z.literal("file_search"),
   vector_store_ids: z.array(z.string()),
-  filters: z.union([
-    ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("eq") })),
-    ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("ne") })),
-    ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gt") })),
-    ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gte") })),
-    ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lt") })),
-    ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lte") })),
-    z.lazy(() => Filters2$inboundSchema).and(
+  filters: discriminatedUnion("type", {
+    eq: ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("eq") })),
+    ne: ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("ne") })),
+    gt: ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gt") })),
+    gte: ComparisonFilter$inboundSchema.and(
+      z.object({ type: z.literal("gte") }),
+    ),
+    lt: ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lt") })),
+    lte: ComparisonFilter$inboundSchema.and(
+      z.object({ type: z.literal("lte") }),
+    ),
+    and: z.lazy(() => Filters2$inboundSchema).and(
       z.object({ type: z.literal("and") }),
     ),
-    z.lazy(() => Filters2$inboundSchema).and(
+    or: z.lazy(() => Filters2$inboundSchema).and(
       z.object({ type: z.literal("or") }),
     ),
-  ]).optional(),
+  }).optional(),
   max_num_results: z.number().int().optional(),
   ranking_options: RankingOptions$inboundSchema.optional(),
 }).transform((v) => {

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