tekimax-ts 0.1.6 → 1.0.0-beta.1

package/dist/index.mjs

@@ -1,1367 +1,2798 @@
 // src/gen/types.ts
 var itemReferenceParamTypeEnum = {
-  item_reference: "item_reference"
-};
+  item_reference: 'item_reference',
+}
 var reasoningSummaryContentParamTypeEnum = {
-  summary_text: "summary_text"
-};
+  summary_text: 'summary_text',
+}
 var reasoningItemParamTypeEnum = {
-  reasoning: "reasoning"
-};
+  reasoning: 'reasoning',
+}
 var inputTextContentParamTypeEnum = {
-  input_text: "input_text"
-};
+  input_text: 'input_text',
+}
 var detailEnumEnum = {
-  low: "low",
-  high: "high",
-  auto: "auto"
-};
+  low: 'low',
+  high: 'high',
+  auto: 'auto',
+}
 var imageDetailEnum = {
-  low: "low",
-  high: "high",
-  auto: "auto"
-};
+  low: 'low',
+  high: 'high',
+  auto: 'auto',
+}
 var inputImageContentParamAutoParamTypeEnum = {
-  input_image: "input_image"
-};
+  input_image: 'input_image',
+}
 var inputFileContentParamTypeEnum = {
-  input_file: "input_file"
-};
+  input_file: 'input_file',
+}
 var userMessageItemParamTypeEnum = {
-  message: "message"
-};
+  message: 'message',
+}
 var userMessageItemParamRoleEnum = {
-  user: "user"
-};
+  user: 'user',
+}
 var systemMessageItemParamTypeEnum = {
-  message: "message"
-};
+  message: 'message',
+}
 var systemMessageItemParamRoleEnum = {
-  system: "system"
-};
+  system: 'system',
+}
 var developerMessageItemParamTypeEnum = {
-  message: "message"
-};
+  message: 'message',
+}
 var developerMessageItemParamRoleEnum = {
-  developer: "developer"
-};
+  developer: 'developer',
+}
 var urlCitationParamTypeEnum = {
-  url_citation: "url_citation"
-};
+  url_citation: 'url_citation',
+}
 var outputTextContentParamTypeEnum = {
-  output_text: "output_text"
-};
+  output_text: 'output_text',
+}
 var refusalContentParamTypeEnum = {
-  refusal: "refusal"
-};
+  refusal: 'refusal',
+}
 var assistantMessageItemParamTypeEnum = {
-  message: "message"
-};
+  message: 'message',
+}
 var assistantMessageItemParamRoleEnum = {
-  assistant: "assistant"
-};
+  assistant: 'assistant',
+}
 var functionCallItemStatusEnum = {
-  in_progress: "in_progress",
-  completed: "completed",
-  incomplete: "incomplete"
-};
+  in_progress: 'in_progress',
+  completed: 'completed',
+  incomplete: 'incomplete',
+}
 var functionCallStatusEnum = {
-  in_progress: "in_progress",
-  completed: "completed",
-  incomplete: "incomplete"
-};
+  in_progress: 'in_progress',
+  completed: 'completed',
+  incomplete: 'incomplete',
+}
 var functionCallItemParamTypeEnum = {
-  function_call: "function_call"
-};
+  function_call: 'function_call',
+}
 var inputVideoContentTypeEnum = {
-  input_video: "input_video"
-};
+  input_video: 'input_video',
+}
 var functionCallOutputItemParamTypeEnum = {
-  function_call_output: "function_call_output"
-};
+  function_call_output: 'function_call_output',
+}
 var includeEnumEnum = {
-  "reasoning.encrypted_content": "reasoning.encrypted_content",
-  "message.output_text.logprobs": "message.output_text.logprobs"
-};
+  'reasoning.encrypted_content': 'reasoning.encrypted_content',
+  'message.output_text.logprobs': 'message.output_text.logprobs',
+}
 var functionToolParamTypeEnum = {
-  function: "function"
-};
+  function: 'function',
+}
 var specificFunctionParamTypeEnum = {
-  function: "function"
-};
+  function: 'function',
+}
 var toolChoiceValueEnumEnum = {
-  none: "none",
-  auto: "auto",
-  required: "required"
-};
+  none: 'none',
+  auto: 'auto',
+  required: 'required',
+}
 var allowedToolsParamTypeEnum = {
-  allowed_tools: "allowed_tools"
-};
+  allowed_tools: 'allowed_tools',
+}
 var verbosityEnumEnum = {
-  low: "low",
-  medium: "medium",
-  high: "high"
-};
+  low: 'low',
+  medium: 'medium',
+  high: 'high',
+}
 var textResponseFormatTypeEnum = {
-  text: "text"
-};
+  text: 'text',
+}
 var jsonSchemaResponseFormatParamTypeEnum = {
-  json_schema: "json_schema"
-};
+  json_schema: 'json_schema',
+}
 var reasoningEffortEnumEnum = {
-  none: "none",
-  low: "low",
-  medium: "medium",
-  high: "high",
-  xhigh: "xhigh"
-};
+  none: 'none',
+  low: 'low',
+  medium: 'medium',
+  high: 'high',
+  xhigh: 'xhigh',
+}
 var reasoningSummaryEnumEnum = {
-  concise: "concise",
-  detailed: "detailed",
-  auto: "auto"
-};
+  concise: 'concise',
+  detailed: 'detailed',
+  auto: 'auto',
+}
 var truncationEnumEnum = {
-  auto: "auto",
-  disabled: "disabled"
-};
+  auto: 'auto',
+  disabled: 'disabled',
+}
 var serviceTierEnumEnum = {
-  auto: "auto",
-  default: "default",
-  flex: "flex",
-  priority: "priority"
-};
+  auto: 'auto',
+  default: 'default',
+  flex: 'flex',
+  priority: 'priority',
+}
 var messageRoleEnum = {
-  user: "user",
-  assistant: "assistant",
-  system: "system",
-  developer: "developer"
-};
+  user: 'user',
+  assistant: 'assistant',
+  system: 'system',
+  developer: 'developer',
+}
 var inputTextContentTypeEnum = {
-  input_text: "input_text"
-};
+  input_text: 'input_text',
+}
 var urlCitationBodyTypeEnum = {
-  url_citation: "url_citation"
-};
+  url_citation: 'url_citation',
+}
 var outputTextContentTypeEnum = {
-  output_text: "output_text"
-};
+  output_text: 'output_text',
+}
 var textContentTypeEnum = {
-  text: "text"
-};
+  text: 'text',
+}
 var summaryTextContentTypeEnum = {
-  summary_text: "summary_text"
-};
+  summary_text: 'summary_text',
+}
 var reasoningTextContentTypeEnum = {
-  reasoning_text: "reasoning_text"
-};
+  reasoning_text: 'reasoning_text',
+}
 var refusalContentTypeEnum = {
-  refusal: "refusal"
-};
+  refusal: 'refusal',
+}
 var inputImageContentTypeEnum = {
-  input_image: "input_image"
-};
+  input_image: 'input_image',
+}
 var inputFileContentTypeEnum = {
-  input_file: "input_file"
-};
+  input_file: 'input_file',
+}
 var messageStatusEnum = {
-  in_progress: "in_progress",
-  completed: "completed",
-  incomplete: "incomplete"
-};
+  in_progress: 'in_progress',
+  completed: 'completed',
+  incomplete: 'incomplete',
+}
 var messageTypeEnum = {
-  message: "message"
-};
+  message: 'message',
+}
 var functionCallTypeEnum = {
-  function_call: "function_call"
-};
+  function_call: 'function_call',
+}
 var functionCallOutputStatusEnumEnum = {
-  in_progress: "in_progress",
-  completed: "completed",
-  incomplete: "incomplete"
-};
+  in_progress: 'in_progress',
+  completed: 'completed',
+  incomplete: 'incomplete',
+}
 var functionCallOutputTypeEnum = {
-  function_call_output: "function_call_output"
-};
+  function_call_output: 'function_call_output',
+}
 var reasoningBodyTypeEnum = {
-  reasoning: "reasoning"
-};
+  reasoning: 'reasoning',
+}
 var functionToolTypeEnum = {
-  function: "function"
-};
+  function: 'function',
+}
 var functionToolChoiceTypeEnum = {
-  function: "function"
-};
+  function: 'function',
+}
 var allowedToolChoiceTypeEnum = {
-  allowed_tools: "allowed_tools"
-};
+  allowed_tools: 'allowed_tools',
+}
 var jsonObjectResponseFormatTypeEnum = {
-  json_object: "json_object"
-};
+  json_object: 'json_object',
+}
 var jsonSchemaResponseFormatTypeEnum = {
-  json_schema: "json_schema"
-};
+  json_schema: 'json_schema',
+}
 var responseResourceObjectEnum = {
-  response: "response"
-};
+  response: 'response',
+}
 var responseCreatedStreamingEventTypeEnum = {
-  "response.created": "response.created"
-};
+  'response.created': 'response.created',
+}
 var responseQueuedStreamingEventTypeEnum = {
-  "response.queued": "response.queued"
-};
+  'response.queued': 'response.queued',
+}
 var responseInProgressStreamingEventTypeEnum = {
-  "response.in_progress": "response.in_progress"
-};
+  'response.in_progress': 'response.in_progress',
+}
 var responseCompletedStreamingEventTypeEnum = {
-  "response.completed": "response.completed"
-};
+  'response.completed': 'response.completed',
+}
 var responseFailedStreamingEventTypeEnum = {
-  "response.failed": "response.failed"
-};
+  'response.failed': 'response.failed',
+}
 var responseIncompleteStreamingEventTypeEnum = {
-  "response.incomplete": "response.incomplete"
-};
+  'response.incomplete': 'response.incomplete',
+}
 var responseOutputItemAddedStreamingEventTypeEnum = {
-  "response.output_item.added": "response.output_item.added"
-};
+  'response.output_item.added': 'response.output_item.added',
+}
 var responseOutputItemDoneStreamingEventTypeEnum = {
-  "response.output_item.done": "response.output_item.done"
-};
+  'response.output_item.done': 'response.output_item.done',
+}
 var responseReasoningSummaryPartAddedStreamingEventTypeEnum = {
-  "response.reasoning_summary_part.added": "response.reasoning_summary_part.added"
-};
+  'response.reasoning_summary_part.added':
+    'response.reasoning_summary_part.added',
+}
 var responseReasoningSummaryPartDoneStreamingEventTypeEnum = {
-  "response.reasoning_summary_part.done": "response.reasoning_summary_part.done"
-};
+  'response.reasoning_summary_part.done':
+    'response.reasoning_summary_part.done',
+}
 var responseContentPartAddedStreamingEventTypeEnum = {
-  "response.content_part.added": "response.content_part.added"
-};
+  'response.content_part.added': 'response.content_part.added',
+}
 var responseContentPartDoneStreamingEventTypeEnum = {
-  "response.content_part.done": "response.content_part.done"
-};
+  'response.content_part.done': 'response.content_part.done',
+}
 var responseOutputTextDeltaStreamingEventTypeEnum = {
-  "response.output_text.delta": "response.output_text.delta"
-};
+  'response.output_text.delta': 'response.output_text.delta',
+}
 var responseOutputTextDoneStreamingEventTypeEnum = {
-  "response.output_text.done": "response.output_text.done"
-};
+  'response.output_text.done': 'response.output_text.done',
+}
 var responseRefusalDeltaStreamingEventTypeEnum = {
-  "response.refusal.delta": "response.refusal.delta"
-};
+  'response.refusal.delta': 'response.refusal.delta',
+}
 var responseRefusalDoneStreamingEventTypeEnum = {
-  "response.refusal.done": "response.refusal.done"
-};
+  'response.refusal.done': 'response.refusal.done',
+}
 var responseReasoningDeltaStreamingEventTypeEnum = {
-  "response.reasoning.delta": "response.reasoning.delta"
-};
+  'response.reasoning.delta': 'response.reasoning.delta',
+}
 var responseReasoningDoneStreamingEventTypeEnum = {
-  "response.reasoning.done": "response.reasoning.done"
-};
+  'response.reasoning.done': 'response.reasoning.done',
+}
 var responseReasoningSummaryDeltaStreamingEventTypeEnum = {
-  "response.reasoning_summary_text.delta": "response.reasoning_summary_text.delta"
-};
+  'response.reasoning_summary_text.delta':
+    'response.reasoning_summary_text.delta',
+}
 var responseReasoningSummaryDoneStreamingEventTypeEnum = {
-  "response.reasoning_summary_text.done": "response.reasoning_summary_text.done"
-};
+  'response.reasoning_summary_text.done':
+    'response.reasoning_summary_text.done',
+}
 var responseOutputTextAnnotationAddedStreamingEventTypeEnum = {
-  "response.output_text.annotation.added": "response.output_text.annotation.added"
-};
+  'response.output_text.annotation.added':
+    'response.output_text.annotation.added',
+}
 var responseFunctionCallArgumentsDeltaStreamingEventTypeEnum = {
-  "response.function_call_arguments.delta": "response.function_call_arguments.delta"
-};
+  'response.function_call_arguments.delta':
+    'response.function_call_arguments.delta',
+}
 var responseFunctionCallArgumentsDoneStreamingEventTypeEnum = {
-  "response.function_call_arguments.done": "response.function_call_arguments.done"
-};
+  'response.function_call_arguments.done':
+    'response.function_call_arguments.done',
+}
 var errorStreamingEventTypeEnum = {
-  error: "error"
-};
+  error: 'error',
+}
 
 // src/gen/zod/functionToolChoiceSchema.ts
-import { z } from "zod";
+import { z } from 'zod'
 var functionToolChoiceSchema = z.object({
-  "type": z.enum(["function"]).default("function"),
-  "name": z.optional(z.string())
-});
+  type: z.enum(['function']).default('function'),
+  name: z.optional(z.string()),
+})
 
 // src/gen/zod/toolChoiceValueEnumSchema.ts
-import { z as z2 } from "zod";
-var toolChoiceValueEnumSchema = z2.enum(["none", "auto", "required"]);
+import { z as z2 } from 'zod'
+var toolChoiceValueEnumSchema = z2.enum(['none', 'auto', 'required'])
 
 // src/gen/zod/allowedToolChoiceSchema.ts
-import { z as z3 } from "zod";
+import { z as z3 } from 'zod'
 var allowedToolChoiceSchema = z3.object({
-  "type": z3.enum(["allowed_tools"]).default("allowed_tools"),
-  "tools": z3.array(z3.lazy(() => functionToolChoiceSchema)),
-  "mode": z3.lazy(() => toolChoiceValueEnumSchema)
-});
+  type: z3.enum(['allowed_tools']).default('allowed_tools'),
+  tools: z3.array(z3.lazy(() => functionToolChoiceSchema)),
+  mode: z3.lazy(() => toolChoiceValueEnumSchema),
+})
 
 // src/gen/zod/specificFunctionParamSchema.ts
-import { z as z4 } from "zod";
+import { z as z4 } from 'zod'
 var specificFunctionParamSchema = z4.object({
-  "type": z4.enum(["function"]).default("function").describe("The tool to call. Always `function`."),
-  "name": z4.string().describe("The name of the function tool to call.")
-});
+  type: z4
+    .enum(['function'])
+    .default('function')
+    .describe('The tool to call. Always `function`.'),
+  name: z4.string().describe('The name of the function tool to call.'),
+})
 
 // src/gen/zod/specificToolChoiceParamSchema.ts
-import { z as z5 } from "zod";
-var specificToolChoiceParamSchema = z5.lazy(() => specificFunctionParamSchema);
+import { z as z5 } from 'zod'
+var specificToolChoiceParamSchema = z5.lazy(() => specificFunctionParamSchema)
 
 // src/gen/zod/allowedToolsParamSchema.ts
-import { z as z6 } from "zod";
+import { z as z6 } from 'zod'
 var allowedToolsParamSchema = z6.object({
-  "type": z6.enum(["allowed_tools"]).default("allowed_tools").describe("The tool choice type. Always `allowed_tools`."),
-  "tools": z6.array(z6.lazy(() => specificToolChoiceParamSchema)).min(1).max(128).describe("The list of tools that are permitted for this request."),
-  "mode": z6.optional(z6.lazy(() => toolChoiceValueEnumSchema).and(z6.any()))
-});
+  type: z6
+    .enum(['allowed_tools'])
+    .default('allowed_tools')
+    .describe('The tool choice type. Always `allowed_tools`.'),
+  tools: z6
+    .array(z6.lazy(() => specificToolChoiceParamSchema))
+    .min(1)
+    .max(128)
+    .describe('The list of tools that are permitted for this request.'),
+  mode: z6.optional(z6.lazy(() => toolChoiceValueEnumSchema).and(z6.any())),
+})
 
 // src/gen/zod/urlCitationBodySchema.ts
-import { z as z7 } from "zod";
-var urlCitationBodySchema = z7.object({
-  "type": z7.enum(["url_citation"]).default("url_citation").describe("The type of the URL citation. Always `url_citation`."),
-  "url": z7.string().describe("The URL of the web resource."),
-  "start_index": z7.number().int().describe("The index of the first character of the URL citation in the message."),
-  "end_index": z7.number().int().describe("The index of the last character of the URL citation in the message."),
-  "title": z7.string().describe("The title of the web resource.")
-}).describe("A citation for a web resource used to generate a model response.");
+import { z as z7 } from 'zod'
+var urlCitationBodySchema = z7
+  .object({
+    type: z7
+      .enum(['url_citation'])
+      .default('url_citation')
+      .describe('The type of the URL citation. Always `url_citation`.'),
+    url: z7.string().describe('The URL of the web resource.'),
+    start_index: z7
+      .number()
+      .int()
+      .describe(
+        'The index of the first character of the URL citation in the message.',
+      ),
+    end_index: z7
+      .number()
+      .int()
+      .describe(
+        'The index of the last character of the URL citation in the message.',
+      ),
+    title: z7.string().describe('The title of the web resource.'),
+  })
+  .describe('A citation for a web resource used to generate a model response.')
 
 // src/gen/zod/annotationSchema.ts
-import { z as z8 } from "zod";
-var annotationSchema = z8.lazy(() => urlCitationBodySchema).and(z8.object({
-  "type": z8.literal("url_citation")
-})).describe("An annotation that applies to a span of output text.");
+import { z as z8 } from 'zod'
+var annotationSchema = z8
+  .lazy(() => urlCitationBodySchema)
+  .and(
+    z8.object({
+      type: z8.literal('url_citation'),
+    }),
+  )
+  .describe('An annotation that applies to a span of output text.')
 
 // src/gen/zod/urlCitationParamSchema.ts
-import { z as z9 } from "zod";
+import { z as z9 } from 'zod'
 var urlCitationParamSchema = z9.object({
-  "type": z9.enum(["url_citation"]).default("url_citation").describe("The citation type. Always `url_citation`."),
-  "start_index": z9.number().int().min(0).describe("The index of the first character of the citation in the message."),
-  "end_index": z9.number().int().min(0).describe("The index of the last character of the citation in the message."),
-  "url": z9.string().describe("The URL of the cited resource."),
-  "title": z9.string().describe("The title of the cited resource.")
-});
+  type: z9
+    .enum(['url_citation'])
+    .default('url_citation')
+    .describe('The citation type. Always `url_citation`.'),
+  start_index: z9
+    .number()
+    .int()
+    .min(0)
+    .describe(
+      'The index of the first character of the citation in the message.',
+    ),
+  end_index: z9
+    .number()
+    .int()
+    .min(0)
+    .describe(
+      'The index of the last character of the citation in the message.',
+    ),
+  url: z9.string().describe('The URL of the cited resource.'),
+  title: z9.string().describe('The title of the cited resource.'),
+})
 
 // src/gen/zod/outputTextContentParamSchema.ts
-import { z as z10 } from "zod";
+import { z as z10 } from 'zod'
 var outputTextContentParamSchema = z10.object({
-  "type": z10.enum(["output_text"]).default("output_text").describe("The content type. Always `output_text`."),
-  "text": z10.string().max(10485760).describe("The text content."),
-  "annotations": z10.optional(z10.array(z10.lazy(() => urlCitationParamSchema)).describe("Citations associated with the text content."))
-});
+  type: z10
+    .enum(['output_text'])
+    .default('output_text')
+    .describe('The content type. Always `output_text`.'),
+  text: z10.string().max(10485760).describe('The text content.'),
+  annotations: z10.optional(
+    z10
+      .array(z10.lazy(() => urlCitationParamSchema))
+      .describe('Citations associated with the text content.'),
+  ),
+})
 
 // src/gen/zod/refusalContentParamSchema.ts
-import { z as z11 } from "zod";
+import { z as z11 } from 'zod'
 var refusalContentParamSchema = z11.object({
-  "type": z11.enum(["refusal"]).default("refusal").describe("The content type. Always `refusal`."),
-  "refusal": z11.string().max(10485760).describe("The refusal text.")
-});
+  type: z11
+    .enum(['refusal'])
+    .default('refusal')
+    .describe('The content type. Always `refusal`.'),
+  refusal: z11.string().max(10485760).describe('The refusal text.'),
+})
 
 // src/gen/zod/assistantMessageItemParamSchema.ts
-import { z as z12 } from "zod";
+import { z as z12 } from 'zod'
 var assistantMessageItemParamSchema = z12.object({
-  "id": z12.optional(z12.union([z12.string(), z12.null()])),
-  "type": z12.enum(["message"]).default("message").describe("The item type. Always `message`."),
-  "role": z12.enum(["assistant"]).default("assistant").describe("The role of the message author. Always `assistant`."),
-  "content": z12.union([z12.array(z12.union([z12.lazy(() => outputTextContentParamSchema).and(z12.object({
-    "type": z12.literal("output_text")
-  })), z12.lazy(() => refusalContentParamSchema).and(z12.object({
-    "type": z12.literal("refusal")
-  }))]).describe("A piece of assistant message content, such as text or a refusal.")), z12.string()]).describe("The message content, as an array of content parts."),
-  "status": z12.optional(z12.union([z12.string(), z12.null()]))
-});
+  id: z12.optional(z12.union([z12.string(), z12.null()])),
+  type: z12
+    .enum(['message'])
+    .default('message')
+    .describe('The item type. Always `message`.'),
+  role: z12
+    .enum(['assistant'])
+    .default('assistant')
+    .describe('The role of the message author. Always `assistant`.'),
+  content: z12
+    .union([
+      z12.array(
+        z12
+          .union([
+            z12
+              .lazy(() => outputTextContentParamSchema)
+              .and(
+                z12.object({
+                  type: z12.literal('output_text'),
+                }),
+              ),
+            z12
+              .lazy(() => refusalContentParamSchema)
+              .and(
+                z12.object({
+                  type: z12.literal('refusal'),
+                }),
+              ),
+          ])
+          .describe(
+            'A piece of assistant message content, such as text or a refusal.',
+          ),
+      ),
+      z12.string(),
+    ])
+    .describe('The message content, as an array of content parts.'),
+  status: z12.optional(z12.union([z12.string(), z12.null()])),
+})
 
 // src/gen/zod/includeEnumSchema.ts
-import { z as z13 } from "zod";
-var includeEnumSchema = z13.enum(["reasoning.encrypted_content", "message.output_text.logprobs"]);
+import { z as z13 } from 'zod'
+var includeEnumSchema = z13.enum([
+  'reasoning.encrypted_content',
+  'message.output_text.logprobs',
+])
 
 // src/gen/zod/functionCallStatusSchema.ts
-import { z as z14 } from "zod";
-var functionCallStatusSchema = z14.enum(["in_progress", "completed", "incomplete"]);
+import { z as z14 } from 'zod'
+var functionCallStatusSchema = z14.enum([
+  'in_progress',
+  'completed',
+  'incomplete',
+])
 
 // src/gen/zod/functionCallItemParamSchema.ts
-import { z as z15 } from "zod";
+import { z as z15 } from 'zod'
 var functionCallItemParamSchema = z15.object({
-  "id": z15.optional(z15.union([z15.string(), z15.null()])),
-  "call_id": z15.string().min(1).max(64).describe("The unique ID of the function tool call generated by the model."),
-  "type": z15.enum(["function_call"]).default("function_call").describe("The item type. Always `function_call`."),
-  "name": z15.string().min(1).max(64).regex(/^[a-zA-Z0-9_-]+$/).describe("The name of the function to call."),
-  "arguments": z15.string().describe("The function arguments as a JSON string."),
-  "status": z15.optional(z15.union([z15.lazy(() => functionCallStatusSchema).and(z15.any()), z15.null()]))
-});
+  id: z15.optional(z15.union([z15.string(), z15.null()])),
+  call_id: z15
+    .string()
+    .min(1)
+    .max(64)
+    .describe(
+      'The unique ID of the function tool call generated by the model.',
+    ),
+  type: z15
+    .enum(['function_call'])
+    .default('function_call')
+    .describe('The item type. Always `function_call`.'),
+  name: z15
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[a-zA-Z0-9_-]+$/)
+    .describe('The name of the function to call.'),
+  arguments: z15.string().describe('The function arguments as a JSON string.'),
+  status: z15.optional(
+    z15.union([
+      z15.lazy(() => functionCallStatusSchema).and(z15.any()),
+      z15.null(),
+    ]),
+  ),
+})
 
 // src/gen/zod/inputFileContentParamSchema.ts
-import { z as z16 } from "zod";
-var inputFileContentParamSchema = z16.object({
-  "type": z16.enum(["input_file"]).default("input_file").describe("The type of the input item. Always `input_file`."),
-  "filename": z16.optional(z16.union([z16.string(), z16.null()])),
-  "file_data": z16.optional(z16.union([z16.string(), z16.null()])),
-  "file_url": z16.optional(z16.union([z16.string(), z16.null()]))
-}).describe("A file input to the model.");
+import { z as z16 } from 'zod'
+var inputFileContentParamSchema = z16
+  .object({
+    type: z16
+      .enum(['input_file'])
+      .default('input_file')
+      .describe('The type of the input item. Always `input_file`.'),
+    filename: z16.optional(z16.union([z16.string(), z16.null()])),
+    file_data: z16.optional(z16.union([z16.string(), z16.null()])),
+    file_url: z16.optional(z16.union([z16.string(), z16.null()])),
+  })
+  .describe('A file input to the model.')
 
 // src/gen/zod/imageDetailSchema.ts
-import { z as z17 } from "zod";
-var imageDetailSchema = z17.enum(["low", "high", "auto"]);
+import { z as z17 } from 'zod'
+var imageDetailSchema = z17.enum(['low', 'high', 'auto'])
 
 // src/gen/zod/inputImageContentParamAutoParamSchema.ts
-import { z as z18 } from "zod";
-var inputImageContentParamAutoParamSchema = z18.object({
-  "type": z18.enum(["input_image"]).default("input_image").describe("The type of the input item. Always `input_image`."),
-  "image_url": z18.optional(z18.union([z18.string(), z18.null()])),
-  "detail": z18.optional(z18.union([z18.lazy(() => imageDetailSchema).and(z18.any()), z18.null()]))
-}).describe("An image input to the model. Learn about [image inputs](/docs/guides/vision)");
+import { z as z18 } from 'zod'
+var inputImageContentParamAutoParamSchema = z18
+  .object({
+    type: z18
+      .enum(['input_image'])
+      .default('input_image')
+      .describe('The type of the input item. Always `input_image`.'),
+    image_url: z18.optional(z18.union([z18.string(), z18.null()])),
+    detail: z18.optional(
+      z18.union([z18.lazy(() => imageDetailSchema).and(z18.any()), z18.null()]),
+    ),
+  })
+  .describe(
+    'An image input to the model. Learn about [image inputs](/docs/guides/vision)',
+  )
 
 // src/gen/zod/inputTextContentParamSchema.ts
-import { z as z19 } from "zod";
-var inputTextContentParamSchema = z19.object({
-  "type": z19.enum(["input_text"]).default("input_text").describe("The type of the input item. Always `input_text`."),
-  "text": z19.string().max(10485760).describe("The text input to the model.")
-}).describe("A text input to the model.");
+import { z as z19 } from 'zod'
+var inputTextContentParamSchema = z19
+  .object({
+    type: z19
+      .enum(['input_text'])
+      .default('input_text')
+      .describe('The type of the input item. Always `input_text`.'),
+    text: z19.string().max(10485760).describe('The text input to the model.'),
+  })
+  .describe('A text input to the model.')
 
 // src/gen/zod/inputVideoContentSchema.ts
-import { z as z20 } from "zod";
-var inputVideoContentSchema = z20.object({
-  "type": z20.enum(["input_video"]).describe("The type of the input content. Always `input_video`."),
-  "video_url": z20.string().describe("A base64 or remote url that resolves to a video file.")
-}).describe("A content block representing a video input to the model.");
+import { z as z20 } from 'zod'
+var inputVideoContentSchema = z20
+  .object({
+    type: z20
+      .enum(['input_video'])
+      .describe('The type of the input content. Always `input_video`.'),
+    video_url: z20
+      .string()
+      .describe('A base64 or remote url that resolves to a video file.'),
+  })
+  .describe('A content block representing a video input to the model.')
 
 // src/gen/zod/functionCallOutputItemParamSchema.ts
-import { z as z21 } from "zod";
-var functionCallOutputItemParamSchema = z21.object({
-  "id": z21.optional(z21.union([z21.string(), z21.null()])),
-  "call_id": z21.string().min(1).max(64).describe("The unique ID of the function tool call generated by the model."),
-  "type": z21.enum(["function_call_output"]).default("function_call_output").describe("The type of the function tool call output. Always `function_call_output`."),
-  "output": z21.union([z21.array(z21.union([z21.lazy(() => inputTextContentParamSchema).and(z21.object({
-    "type": z21.literal("input_text")
-  })), z21.lazy(() => inputImageContentParamAutoParamSchema).and(z21.object({
-    "type": z21.literal("input_image")
-  })), z21.lazy(() => inputFileContentParamSchema).and(z21.object({
-    "type": z21.literal("input_file")
-  })), z21.lazy(() => inputVideoContentSchema).and(z21.object({
-    "type": z21.literal("input_video")
-  }))]).describe("A piece of message content, such as text, an image, or a file.")), z21.string()]).describe("Text, image, or file output of the function tool call."),
-  "status": z21.optional(z21.union([z21.lazy(() => functionCallStatusSchema).and(z21.any()), z21.null()]))
-}).describe("The output of a function tool call.");
+import { z as z21 } from 'zod'
+var functionCallOutputItemParamSchema = z21
+  .object({
+    id: z21.optional(z21.union([z21.string(), z21.null()])),
+    call_id: z21
+      .string()
+      .min(1)
+      .max(64)
+      .describe(
+        'The unique ID of the function tool call generated by the model.',
+      ),
+    type: z21
+      .enum(['function_call_output'])
+      .default('function_call_output')
+      .describe(
+        'The type of the function tool call output. Always `function_call_output`.',
+      ),
+    output: z21
+      .union([
+        z21.array(
+          z21
+            .union([
+              z21
+                .lazy(() => inputTextContentParamSchema)
+                .and(
+                  z21.object({
+                    type: z21.literal('input_text'),
+                  }),
+                ),
+              z21
+                .lazy(() => inputImageContentParamAutoParamSchema)
+                .and(
+                  z21.object({
+                    type: z21.literal('input_image'),
+                  }),
+                ),
+              z21
+                .lazy(() => inputFileContentParamSchema)
+                .and(
+                  z21.object({
+                    type: z21.literal('input_file'),
+                  }),
+                ),
+              z21
+                .lazy(() => inputVideoContentSchema)
+                .and(
+                  z21.object({
+                    type: z21.literal('input_video'),
+                  }),
+                ),
+            ])
+            .describe(
+              'A piece of message content, such as text, an image, or a file.',
+            ),
+        ),
+        z21.string(),
+      ])
+      .describe('Text, image, or file output of the function tool call.'),
+    status: z21.optional(
+      z21.union([
+        z21.lazy(() => functionCallStatusSchema).and(z21.any()),
+        z21.null(),
+      ]),
+    ),
+  })
+  .describe('The output of a function tool call.')
 
 // src/gen/zod/itemReferenceParamSchema.ts
-import { z as z22 } from "zod";
-var itemReferenceParamSchema = z22.object({
-  "type": z22.optional(z22.union([z22.enum(["item_reference"]), z22.null()])),
-  "id": z22.string().describe("The ID of the item to reference.")
-}).describe("An internal identifier for an item to reference.");
+import { z as z22 } from 'zod'
+var itemReferenceParamSchema = z22
+  .object({
+    type: z22.optional(z22.union([z22.enum(['item_reference']), z22.null()])),
+    id: z22.string().describe('The ID of the item to reference.'),
+  })
+  .describe('An internal identifier for an item to reference.')
 
 // src/gen/zod/reasoningSummaryContentParamSchema.ts
-import { z as z23 } from "zod";
+import { z as z23 } from 'zod'
 var reasoningSummaryContentParamSchema = z23.object({
-  "type": z23.enum(["summary_text"]).default("summary_text").describe("The content type. Always `summary_text`."),
-  "text": z23.string().max(10485760).describe("The reasoning summary text.")
-});
+  type: z23
+    .enum(['summary_text'])
+    .default('summary_text')
+    .describe('The content type. Always `summary_text`.'),
+  text: z23.string().max(10485760).describe('The reasoning summary text.'),
+})
 
 // src/gen/zod/reasoningItemParamSchema.ts
-import { z as z24 } from "zod";
+import { z as z24 } from 'zod'
 var reasoningItemParamSchema = z24.object({
-  "id": z24.optional(z24.union([z24.string(), z24.null()])),
-  "type": z24.enum(["reasoning"]).default("reasoning").describe("The item type. Always `reasoning`."),
-  "summary": z24.array(z24.lazy(() => reasoningSummaryContentParamSchema)).describe("Reasoning summary content associated with this item."),
-  "content": z24.optional(z24.null()),
-  "encrypted_content": z24.optional(z24.union([z24.string(), z24.null()]))
-});
+  id: z24.optional(z24.union([z24.string(), z24.null()])),
+  type: z24
+    .enum(['reasoning'])
+    .default('reasoning')
+    .describe('The item type. Always `reasoning`.'),
+  summary: z24
+    .array(z24.lazy(() => reasoningSummaryContentParamSchema))
+    .describe('Reasoning summary content associated with this item.'),
+  content: z24.optional(z24.null()),
+  encrypted_content: z24.optional(z24.union([z24.string(), z24.null()])),
+})
 
 // src/gen/zod/itemParamSchema.ts
-import { z as z25 } from "zod";
-var itemParamSchema = z25.union([z25.lazy(() => itemReferenceParamSchema).and(z25.object({
-  "type": z25.literal("Item reference")
-})), z25.lazy(() => reasoningItemParamSchema).and(z25.object({
-  "type": z25.literal("reasoning")
-})), z25.lazy(() => assistantMessageItemParamSchema).and(z25.object({
-  "type": z25.literal("message")
-})), z25.lazy(() => functionCallItemParamSchema).and(z25.object({
-  "type": z25.literal("function_call")
-})), z25.lazy(() => functionCallOutputItemParamSchema).and(z25.object({
-  "type": z25.literal("function_call_output")
-}))]);
+import { z as z25 } from 'zod'
+var itemParamSchema = z25.union([
+  z25
+    .lazy(() => itemReferenceParamSchema)
+    .and(
+      z25.object({
+        type: z25.literal('Item reference'),
+      }),
+    ),
+  z25
+    .lazy(() => reasoningItemParamSchema)
+    .and(
+      z25.object({
+        type: z25.literal('reasoning'),
+      }),
+    ),
+  z25
+    .lazy(() => assistantMessageItemParamSchema)
+    .and(
+      z25.object({
+        type: z25.literal('message'),
+      }),
+    ),
+  z25
+    .lazy(() => functionCallItemParamSchema)
+    .and(
+      z25.object({
+        type: z25.literal('function_call'),
+      }),
+    ),
+  z25
+    .lazy(() => functionCallOutputItemParamSchema)
+    .and(
+      z25.object({
+        type: z25.literal('function_call_output'),
+      }),
+    ),
+])
 
 // src/gen/zod/metadataParamSchema.ts
-import { z as z26 } from "zod";
-var metadataParamSchema = z26.object({}).catchall(z26.string().max(512)).describe("Set of 16 key-value pairs that can be attached to an object. This can be         useful for storing additional information about the object in a structured         format, and querying for objects via API or the dashboard.\n        Keys are strings with a maximum length of 64 characters. Values are strings         with a maximum length of 512 characters.");
+import { z as z26 } from 'zod'
+var metadataParamSchema = z26
+  .object({})
+  .catchall(z26.string().max(512))
+  .describe(
+    'Set of 16 key-value pairs that can be attached to an object. This can be         useful for storing additional information about the object in a structured         format, and querying for objects via API or the dashboard.\n        Keys are strings with a maximum length of 64 characters. Values are strings         with a maximum length of 512 characters.',
+  )
 
 // src/gen/zod/reasoningEffortEnumSchema.ts
-import { z as z27 } from "zod";
-var reasoningEffortEnumSchema = z27.enum(["none", "low", "medium", "high", "xhigh"]);
+import { z as z27 } from 'zod'
+var reasoningEffortEnumSchema = z27.enum([
+  'none',
+  'low',
+  'medium',
+  'high',
+  'xhigh',
+])
 
 // src/gen/zod/reasoningSummaryEnumSchema.ts
-import { z as z28 } from "zod";
-var reasoningSummaryEnumSchema = z28.enum(["concise", "detailed", "auto"]);
+import { z as z28 } from 'zod'
+var reasoningSummaryEnumSchema = z28.enum(['concise', 'detailed', 'auto'])
 
 // src/gen/zod/reasoningParamSchema.ts
-import { z as z29 } from "zod";
-var reasoningParamSchema = z29.object({
-  "effort": z29.optional(z29.union([z29.lazy(() => reasoningEffortEnumSchema), z29.null()])),
-  "summary": z29.optional(z29.union([z29.lazy(() => reasoningSummaryEnumSchema).and(z29.any()), z29.null()]))
-}).describe("**gpt-5 and o-series models only** Configuration options for [reasoning models](https://platform.openai.com/docs/guides/reasoning).");
+import { z as z29 } from 'zod'
+var reasoningParamSchema = z29
+  .object({
+    effort: z29.optional(
+      z29.union([z29.lazy(() => reasoningEffortEnumSchema), z29.null()]),
+    ),
+    summary: z29.optional(
+      z29.union([
+        z29.lazy(() => reasoningSummaryEnumSchema).and(z29.any()),
+        z29.null(),
+      ]),
+    ),
+  })
+  .describe(
+    '**gpt-5 and o-series models only** Configuration options for [reasoning models](https://platform.openai.com/docs/guides/reasoning).',
+  )
 
 // src/gen/zod/emptyModelParamSchema.ts
-import { z as z30 } from "zod";
-var emptyModelParamSchema = z30.object({});
+import { z as z30 } from 'zod'
+var emptyModelParamSchema = z30.object({})
 
 // src/gen/zod/functionToolParamSchema.ts
-import { z as z31 } from "zod";
+import { z as z31 } from 'zod'
 var functionToolParamSchema = z31.object({
-  "name": z31.string().min(1).max(64).regex(/^[a-zA-Z0-9_-]+$/),
-  "description": z31.optional(z31.union([z31.string(), z31.null()])),
-  "parameters": z31.optional(z31.union([z31.lazy(() => emptyModelParamSchema), z31.null()])),
-  "strict": z31.optional(z31.boolean()),
-  "type": z31.enum(["function"]).default("function")
-});
+  name: z31
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[a-zA-Z0-9_-]+$/),
+  description: z31.optional(z31.union([z31.string(), z31.null()])),
+  parameters: z31.optional(
+    z31.union([z31.lazy(() => emptyModelParamSchema), z31.null()]),
+  ),
+  strict: z31.optional(z31.boolean()),
+  type: z31.enum(['function']).default('function'),
+})
 
 // src/gen/zod/responsesToolParamSchema.ts
-import { z as z32 } from "zod";
-var responsesToolParamSchema = z32.lazy(() => functionToolParamSchema).and(z32.object({
-  "type": z32.literal("function")
-}));
+import { z as z32 } from 'zod'
+var responsesToolParamSchema = z32
+  .lazy(() => functionToolParamSchema)
+  .and(
+    z32.object({
+      type: z32.literal('function'),
+    }),
+  )
 
 // src/gen/zod/serviceTierEnumSchema.ts
-import { z as z33 } from "zod";
-var serviceTierEnumSchema = z33.enum(["auto", "default", "flex", "priority"]);
+import { z as z33 } from 'zod'
+var serviceTierEnumSchema = z33.enum(['auto', 'default', 'flex', 'priority'])
 
 // src/gen/zod/streamOptionsParamSchema.ts
-import { z as z34 } from "zod";
-var streamOptionsParamSchema = z34.object({
-  "include_obfuscation": z34.optional(z34.boolean().describe("Whether to obfuscate sensitive information in streamed output. Defaults to `true`."))
-}).describe("Options that control streamed response behavior.");
+import { z as z34 } from 'zod'
+var streamOptionsParamSchema = z34
+  .object({
+    include_obfuscation: z34.optional(
+      z34
+        .boolean()
+        .describe(
+          'Whether to obfuscate sensitive information in streamed output. Defaults to `true`.',
+        ),
+    ),
+  })
+  .describe('Options that control streamed response behavior.')
 
 // src/gen/zod/jsonSchemaResponseFormatParamSchema.ts
-import { z as z35 } from "zod";
+import { z as z35 } from 'zod'
 var jsonSchemaResponseFormatParamSchema = z35.object({
-  "type": z35.optional(z35.enum(["json_schema"]).describe("The type of response format being defined. Always `json_schema`.")),
-  "description": z35.optional(z35.string().describe("A description of what the response format is for, used by the model to\ndetermine how to respond in the format.\n")),
-  "name": z35.optional(z35.string().describe("The name of the response format. Must be a-z, A-Z, 0-9, or contain\nunderscores and dashes, with a maximum length of 64.\n")),
-  "schema": z35.optional(z35.object({}).catchall(z35.any()).describe("The schema for the response format, described as a JSON Schema object.\n")),
-  "strict": z35.optional(z35.union([z35.boolean(), z35.null()]))
-});
+  type: z35.optional(
+    z35
+      .enum(['json_schema'])
+      .describe(
+        'The type of response format being defined. Always `json_schema`.',
+      ),
+  ),
+  description: z35.optional(
+    z35
+      .string()
+      .describe(
+        'A description of what the response format is for, used by the model to\ndetermine how to respond in the format.\n',
+      ),
+  ),
+  name: z35.optional(
+    z35
+      .string()
+      .describe(
+        'The name of the response format. Must be a-z, A-Z, 0-9, or contain\nunderscores and dashes, with a maximum length of 64.\n',
+      ),
+  ),
+  schema: z35.optional(
+    z35
+      .object({})
+      .catchall(z35.any())
+      .describe(
+        'The schema for the response format, described as a JSON Schema object.\n',
+      ),
+  ),
+  strict: z35.optional(z35.union([z35.boolean(), z35.null()])),
+})
 
 // src/gen/zod/textResponseFormatSchema.ts
-import { z as z36 } from "zod";
+import { z as z36 } from 'zod'
 var textResponseFormatSchema = z36.object({
-  "type": z36.enum(["text"]).default("text")
-});
+  type: z36.enum(['text']).default('text'),
+})
 
 // src/gen/zod/textFormatParamSchema.ts
-import { z as z37 } from "zod";
-var textFormatParamSchema = z37.union([z37.lazy(() => textResponseFormatSchema), z37.lazy(() => jsonSchemaResponseFormatParamSchema)]);
+import { z as z37 } from 'zod'
+var textFormatParamSchema = z37.union([
+  z37.lazy(() => textResponseFormatSchema),
+  z37.lazy(() => jsonSchemaResponseFormatParamSchema),
+])
 
 // src/gen/zod/verbosityEnumSchema.ts
-import { z as z38 } from "zod";
-var verbosityEnumSchema = z38.enum(["low", "medium", "high"]);
+import { z as z38 } from 'zod'
+var verbosityEnumSchema = z38.enum(['low', 'medium', 'high'])
 
 // src/gen/zod/textParamSchema.ts
-import { z as z39 } from "zod";
+import { z as z39 } from 'zod'
 var textParamSchema = z39.object({
-  "format": z39.optional(z39.union([z39.lazy(() => textFormatParamSchema), z39.null()]).describe("The format configuration for text output.")),
-  "verbosity": z39.optional(z39.lazy(() => verbosityEnumSchema).and(z39.any()))
-});
+  format: z39.optional(
+    z39
+      .union([z39.lazy(() => textFormatParamSchema), z39.null()])
+      .describe('The format configuration for text output.'),
+  ),
+  verbosity: z39.optional(z39.lazy(() => verbosityEnumSchema).and(z39.any())),
+})
 
 // src/gen/zod/toolChoiceParamSchema.ts
-import { z as z40 } from "zod";
-var toolChoiceParamSchema = z40.union([z40.lazy(() => specificToolChoiceParamSchema), z40.lazy(() => toolChoiceValueEnumSchema), z40.lazy(() => allowedToolsParamSchema)]).describe("Controls which tool the model should use, if any.");
+import { z as z40 } from 'zod'
+var toolChoiceParamSchema = z40
+  .union([
+    z40.lazy(() => specificToolChoiceParamSchema),
+    z40.lazy(() => toolChoiceValueEnumSchema),
+    z40.lazy(() => allowedToolsParamSchema),
+  ])
+  .describe('Controls which tool the model should use, if any.')
 
 // src/gen/zod/truncationEnumSchema.ts
-import { z as z41 } from "zod";
-var truncationEnumSchema = z41.enum(["auto", "disabled"]);
+import { z as z41 } from 'zod'
+var truncationEnumSchema = z41.enum(['auto', 'disabled'])
 
 // src/gen/zod/createResponseBodySchema.ts
-import { z as z42 } from "zod";
+import { z as z42 } from 'zod'
 var createResponseBodySchema = z42.object({
-  "model": z42.optional(z42.union([z42.string(), z42.null()])),
-  "input": z42.optional(z42.union([z42.union([z42.array(z42.lazy(() => itemParamSchema)), z42.string()]), z42.null()])),
-  "previous_response_id": z42.optional(z42.union([z42.string(), z42.null()])),
-  "include": z42.optional(z42.array(z42.lazy(() => includeEnumSchema))),
-  "tools": z42.optional(z42.union([z42.array(z42.lazy(() => responsesToolParamSchema)), z42.null()])),
-  "tool_choice": z42.optional(z42.union([z42.lazy(() => toolChoiceParamSchema).and(z42.any()), z42.null()])),
-  "metadata": z42.optional(z42.union([z42.lazy(() => metadataParamSchema).and(z42.any()), z42.null()])),
-  "text": z42.optional(z42.union([z42.lazy(() => textParamSchema).and(z42.any()), z42.null()])),
-  "temperature": z42.optional(z42.union([z42.number(), z42.null()])),
-  "top_p": z42.optional(z42.union([z42.number(), z42.null()])),
-  "presence_penalty": z42.optional(z42.union([z42.number(), z42.null()])),
-  "frequency_penalty": z42.optional(z42.union([z42.number(), z42.null()])),
-  "parallel_tool_calls": z42.optional(z42.union([z42.boolean(), z42.null()])),
-  "stream": z42.optional(z42.boolean().describe("Whether to stream response events as server-sent events.")),
-  "stream_options": z42.optional(z42.union([z42.lazy(() => streamOptionsParamSchema).and(z42.any()), z42.null()])),
-  "background": z42.optional(z42.boolean().describe("Whether to run the request in the background and return immediately.")),
-  "max_output_tokens": z42.optional(z42.union([z42.number().int(), z42.null()])),
-  "max_tool_calls": z42.optional(z42.union([z42.number().int(), z42.null()])),
-  "reasoning": z42.optional(z42.union([z42.lazy(() => reasoningParamSchema).and(z42.any()), z42.null()])),
-  "safety_identifier": z42.optional(z42.union([z42.string(), z42.null()])),
-  "prompt_cache_key": z42.optional(z42.union([z42.string(), z42.null()])),
-  "truncation": z42.optional(z42.lazy(() => truncationEnumSchema).and(z42.any())),
-  "instructions": z42.optional(z42.union([z42.string(), z42.null()])),
-  "store": z42.optional(z42.boolean().describe("Whether to store the response so it can be retrieved later.")),
-  "service_tier": z42.optional(z42.lazy(() => serviceTierEnumSchema).and(z42.any())),
-  "top_logprobs": z42.optional(z42.union([z42.number().int(), z42.null()]))
-});
+  model: z42.optional(z42.union([z42.string(), z42.null()])),
+  input: z42.optional(
+    z42.union([
+      z42.union([z42.array(z42.lazy(() => itemParamSchema)), z42.string()]),
+      z42.null(),
+    ]),
+  ),
+  previous_response_id: z42.optional(z42.union([z42.string(), z42.null()])),
+  include: z42.optional(z42.array(z42.lazy(() => includeEnumSchema))),
+  tools: z42.optional(
+    z42.union([
+      z42.array(z42.lazy(() => responsesToolParamSchema)),
+      z42.null(),
+    ]),
+  ),
+  tool_choice: z42.optional(
+    z42.union([
+      z42.lazy(() => toolChoiceParamSchema).and(z42.any()),
+      z42.null(),
+    ]),
+  ),
+  metadata: z42.optional(
+    z42.union([z42.lazy(() => metadataParamSchema).and(z42.any()), z42.null()]),
+  ),
+  text: z42.optional(
+    z42.union([z42.lazy(() => textParamSchema).and(z42.any()), z42.null()]),
+  ),
+  temperature: z42.optional(z42.union([z42.number(), z42.null()])),
+  top_p: z42.optional(z42.union([z42.number(), z42.null()])),
+  presence_penalty: z42.optional(z42.union([z42.number(), z42.null()])),
+  frequency_penalty: z42.optional(z42.union([z42.number(), z42.null()])),
+  parallel_tool_calls: z42.optional(z42.union([z42.boolean(), z42.null()])),
+  stream: z42.optional(
+    z42
+      .boolean()
+      .describe('Whether to stream response events as server-sent events.'),
+  ),
+  stream_options: z42.optional(
+    z42.union([
+      z42.lazy(() => streamOptionsParamSchema).and(z42.any()),
+      z42.null(),
+    ]),
+  ),
+  background: z42.optional(
+    z42
+      .boolean()
+      .describe(
+        'Whether to run the request in the background and return immediately.',
+      ),
+  ),
+  max_output_tokens: z42.optional(z42.union([z42.number().int(), z42.null()])),
+  max_tool_calls: z42.optional(z42.union([z42.number().int(), z42.null()])),
+  reasoning: z42.optional(
+    z42.union([
+      z42.lazy(() => reasoningParamSchema).and(z42.any()),
+      z42.null(),
+    ]),
+  ),
+  safety_identifier: z42.optional(z42.union([z42.string(), z42.null()])),
+  prompt_cache_key: z42.optional(z42.union([z42.string(), z42.null()])),
+  truncation: z42.optional(z42.lazy(() => truncationEnumSchema).and(z42.any())),
+  instructions: z42.optional(z42.union([z42.string(), z42.null()])),
+  store: z42.optional(
+    z42
+      .boolean()
+      .describe('Whether to store the response so it can be retrieved later.'),
+  ),
+  service_tier: z42.optional(
+    z42.lazy(() => serviceTierEnumSchema).and(z42.any()),
+  ),
+  top_logprobs: z42.optional(z42.union([z42.number().int(), z42.null()])),
+})
 
 // src/gen/zod/errorSchema.ts
-import { z as z43 } from "zod";
-var errorSchema = z43.object({
-  "code": z43.string().describe("A machine-readable error code that was returned."),
-  "message": z43.string().describe("A human-readable description of the error that was returned.")
-}).describe("An error that occurred while generating the response.");
+import { z as z43 } from 'zod'
+var errorSchema = z43
+  .object({
+    code: z43
+      .string()
+      .describe('A machine-readable error code that was returned.'),
+    message: z43
+      .string()
+      .describe('A human-readable description of the error that was returned.'),
+  })
+  .describe('An error that occurred while generating the response.')
 
 // src/gen/zod/incompleteDetailsSchema.ts
-import { z as z44 } from "zod";
-var incompleteDetailsSchema = z44.object({
-  "reason": z44.string().describe("The reason the response could not be completed.")
-}).describe("Details about why the response was incomplete.");
+import { z as z44 } from 'zod'
+var incompleteDetailsSchema = z44
+  .object({
+    reason: z44
+      .string()
+      .describe('The reason the response could not be completed.'),
+  })
+  .describe('Details about why the response was incomplete.')
 
 // src/gen/zod/functionCallOutputStatusEnumSchema.ts
-import { z as z45 } from "zod";
-var functionCallOutputStatusEnumSchema = z45.enum(["in_progress", "completed", "incomplete"]).describe("Similar to `FunctionCallStatus`. All three options are allowed here for compatibility, but because in practice these items will be provided by developers, only `completed` should be used.");
+import { z as z45 } from 'zod'
+var functionCallOutputStatusEnumSchema = z45
+  .enum(['in_progress', 'completed', 'incomplete'])
+  .describe(
+    'Similar to `FunctionCallStatus`. All three options are allowed here for compatibility, but because in practice these items will be provided by developers, only `completed` should be used.',
+  )
 
 // src/gen/zod/inputFileContentSchema.ts
-import { z as z46 } from "zod";
-var inputFileContentSchema = z46.object({
-  "type": z46.enum(["input_file"]).default("input_file").describe("The type of the input item. Always `input_file`."),
-  "filename": z46.optional(z46.string().describe("The name of the file to be sent to the model.")),
-  "file_url": z46.optional(z46.string().describe("The URL of the file to be sent to the model."))
-}).describe("A file input to the model.");
+import { z as z46 } from 'zod'
+var inputFileContentSchema = z46
+  .object({
+    type: z46
+      .enum(['input_file'])
+      .default('input_file')
+      .describe('The type of the input item. Always `input_file`.'),
+    filename: z46.optional(
+      z46.string().describe('The name of the file to be sent to the model.'),
+    ),
+    file_url: z46.optional(
+      z46.string().describe('The URL of the file to be sent to the model.'),
+    ),
+  })
+  .describe('A file input to the model.')
 
 // src/gen/zod/inputImageContentSchema.ts
-import { z as z47 } from "zod";
-var inputImageContentSchema = z47.object({
-  "type": z47.enum(["input_image"]).default("input_image").describe("The type of the input item. Always `input_image`."),
-  "image_url": z47.union([z47.string(), z47.null()]),
-  "detail": z47.lazy(() => imageDetailSchema).and(z47.any())
-}).describe("An image input to the model. Learn about [image inputs](/docs/guides/vision).");
+import { z as z47 } from 'zod'
+var inputImageContentSchema = z47
+  .object({
+    type: z47
+      .enum(['input_image'])
+      .default('input_image')
+      .describe('The type of the input item. Always `input_image`.'),
+    image_url: z47.union([z47.string(), z47.null()]),
+    detail: z47.lazy(() => imageDetailSchema).and(z47.any()),
+  })
+  .describe(
+    'An image input to the model. Learn about [image inputs](/docs/guides/vision).',
+  )
 
 // src/gen/zod/inputTextContentSchema.ts
-import { z as z48 } from "zod";
-var inputTextContentSchema = z48.object({
-  "type": z48.enum(["input_text"]).default("input_text").describe("The type of the input item. Always `input_text`."),
-  "text": z48.string().describe("The text input to the model.")
-}).describe("A text input to the model.");
+import { z as z48 } from 'zod'
+var inputTextContentSchema = z48
+  .object({
+    type: z48
+      .enum(['input_text'])
+      .default('input_text')
+      .describe('The type of the input item. Always `input_text`.'),
+    text: z48.string().describe('The text input to the model.'),
+  })
+  .describe('A text input to the model.')
 
 // src/gen/zod/functionCallOutputSchema.ts
-import { z as z49 } from "zod";
-var functionCallOutputSchema = z49.object({
-  "type": z49.enum(["function_call_output"]).default("function_call_output").describe("The type of the function tool call output. Always `function_call_output`."),
-  "id": z49.string().describe("The unique ID of the function tool call output. Populated when this item is returned via API."),
-  "call_id": z49.string().describe("The unique ID of the function tool call generated by the model."),
-  "output": z49.union([z49.array(z49.union([z49.lazy(() => inputTextContentSchema).and(z49.object({
-    "type": z49.literal("input_text")
-  })), z49.lazy(() => inputImageContentSchema).and(z49.object({
-    "type": z49.literal("input_image")
-  })), z49.lazy(() => inputFileContentSchema).and(z49.object({
-    "type": z49.literal("input_file")
-  }))]).describe("A content part that makes up an input or output item.")), z49.string()]),
-  "status": z49.lazy(() => functionCallOutputStatusEnumSchema).and(z49.any())
-}).describe("A function tool call output that was returned by the tool.");
+import { z as z49 } from 'zod'
+var functionCallOutputSchema = z49
+  .object({
+    type: z49
+      .enum(['function_call_output'])
+      .default('function_call_output')
+      .describe(
+        'The type of the function tool call output. Always `function_call_output`.',
+      ),
+    id: z49
+      .string()
+      .describe(
+        'The unique ID of the function tool call output. Populated when this item is returned via API.',
+      ),
+    call_id: z49
+      .string()
+      .describe(
+        'The unique ID of the function tool call generated by the model.',
+      ),
+    output: z49.union([
+      z49.array(
+        z49
+          .union([
+            z49
+              .lazy(() => inputTextContentSchema)
+              .and(
+                z49.object({
+                  type: z49.literal('input_text'),
+                }),
+              ),
+            z49
+              .lazy(() => inputImageContentSchema)
+              .and(
+                z49.object({
+                  type: z49.literal('input_image'),
+                }),
+              ),
+            z49
+              .lazy(() => inputFileContentSchema)
+              .and(
+                z49.object({
+                  type: z49.literal('input_file'),
+                }),
+              ),
+          ])
+          .describe('A content part that makes up an input or output item.'),
+      ),
+      z49.string(),
+    ]),
+    status: z49.lazy(() => functionCallOutputStatusEnumSchema).and(z49.any()),
+  })
+  .describe('A function tool call output that was returned by the tool.')
 
 // src/gen/zod/functionCallSchema.ts
-import { z as z50 } from "zod";
-var functionCallSchema = z50.object({
-  "type": z50.enum(["function_call"]).default("function_call").describe("The type of the item. Always `function_call`."),
-  "id": z50.string().describe("The unique ID of the function call item."),
-  "call_id": z50.string().describe("The unique ID of the function tool call that was generated."),
-  "name": z50.string().describe("The name of the function that was called."),
-  "arguments": z50.string().describe("The arguments JSON string that was generated."),
-  "status": z50.lazy(() => functionCallStatusSchema).and(z50.any())
-}).describe("A function tool call that was generated by the model.");
+import { z as z50 } from 'zod'
+var functionCallSchema = z50
+  .object({
+    type: z50
+      .enum(['function_call'])
+      .default('function_call')
+      .describe('The type of the item. Always `function_call`.'),
+    id: z50.string().describe('The unique ID of the function call item.'),
+    call_id: z50
+      .string()
+      .describe('The unique ID of the function tool call that was generated.'),
+    name: z50.string().describe('The name of the function that was called.'),
+    arguments: z50
+      .string()
+      .describe('The arguments JSON string that was generated.'),
+    status: z50.lazy(() => functionCallStatusSchema).and(z50.any()),
+  })
+  .describe('A function tool call that was generated by the model.')
 
 // src/gen/zod/messageRoleSchema.ts
-import { z as z51 } from "zod";
-var messageRoleSchema = z51.enum(["user", "assistant", "system", "developer"]);
+import { z as z51 } from 'zod'
+var messageRoleSchema = z51.enum(['user', 'assistant', 'system', 'developer'])
 
 // src/gen/zod/messageStatusSchema.ts
-import { z as z52 } from "zod";
-var messageStatusSchema = z52.enum(["in_progress", "completed", "incomplete"]);
+import { z as z52 } from 'zod'
+var messageStatusSchema = z52.enum(['in_progress', 'completed', 'incomplete'])
 
 // src/gen/zod/topLogProbSchema.ts
-import { z as z53 } from "zod";
-var topLogProbSchema = z53.object({
-  "token": z53.string(),
-  "logprob": z53.number(),
-  "bytes": z53.array(z53.number().int())
-}).describe("The top log probability of a token.");
+import { z as z53 } from 'zod'
+var topLogProbSchema = z53
+  .object({
+    token: z53.string(),
+    logprob: z53.number(),
+    bytes: z53.array(z53.number().int()),
+  })
+  .describe('The top log probability of a token.')
 
 // src/gen/zod/logProbSchema.ts
-import { z as z54 } from "zod";
-var logProbSchema = z54.object({
-  "token": z54.string(),
-  "logprob": z54.number(),
-  "bytes": z54.array(z54.number().int()),
-  "top_logprobs": z54.array(z54.lazy(() => topLogProbSchema).describe("The top log probability of a token."))
-}).describe("The log probability of a token.");
+import { z as z54 } from 'zod'
+var logProbSchema = z54
+  .object({
+    token: z54.string(),
+    logprob: z54.number(),
+    bytes: z54.array(z54.number().int()),
+    top_logprobs: z54.array(
+      z54
+        .lazy(() => topLogProbSchema)
+        .describe('The top log probability of a token.'),
+    ),
+  })
+  .describe('The log probability of a token.')
 
 // src/gen/zod/outputTextContentSchema.ts
-import { z as z55 } from "zod";
-var outputTextContentSchema = z55.object({
-  "type": z55.enum(["output_text"]).default("output_text").describe("The type of the output text. Always `output_text`."),
-  "text": z55.string().describe("The text output from the model."),
-  "annotations": z55.array(z55.lazy(() => annotationSchema).describe("An annotation that applies to a span of output text.")).describe("The annotations of the text output."),
-  "logprobs": z55.array(z55.lazy(() => logProbSchema).describe("The log probability of a token."))
-}).describe("A text output from the model.");
+import { z as z55 } from 'zod'
+var outputTextContentSchema = z55
+  .object({
+    type: z55
+      .enum(['output_text'])
+      .default('output_text')
+      .describe('The type of the output text. Always `output_text`.'),
+    text: z55.string().describe('The text output from the model.'),
+    annotations: z55
+      .array(
+        z55
+          .lazy(() => annotationSchema)
+          .describe('An annotation that applies to a span of output text.'),
+      )
+      .describe('The annotations of the text output.'),
+    logprobs: z55.array(
+      z55.lazy(() => logProbSchema).describe('The log probability of a token.'),
+    ),
+  })
+  .describe('A text output from the model.')
 
 // src/gen/zod/reasoningTextContentSchema.ts
-import { z as z56 } from "zod";
-var reasoningTextContentSchema = z56.object({
-  "type": z56.enum(["reasoning_text"]).default("reasoning_text").describe("The type of the reasoning text. Always `reasoning_text`."),
-  "text": z56.string().describe("The reasoning text from the model.")
-}).describe("Reasoning text from the model.");
+import { z as z56 } from 'zod'
+var reasoningTextContentSchema = z56
+  .object({
+    type: z56
+      .enum(['reasoning_text'])
+      .default('reasoning_text')
+      .describe('The type of the reasoning text. Always `reasoning_text`.'),
+    text: z56.string().describe('The reasoning text from the model.'),
+  })
+  .describe('Reasoning text from the model.')
 
 // src/gen/zod/refusalContentSchema.ts
-import { z as z57 } from "zod";
-var refusalContentSchema = z57.object({
-  "type": z57.enum(["refusal"]).default("refusal").describe("The type of the refusal. Always `refusal`."),
-  "refusal": z57.string().describe("The refusal explanation from the model.")
-}).describe("A refusal from the model.");
+import { z as z57 } from 'zod'
+var refusalContentSchema = z57
+  .object({
+    type: z57
+      .enum(['refusal'])
+      .default('refusal')
+      .describe('The type of the refusal. Always `refusal`.'),
+    refusal: z57.string().describe('The refusal explanation from the model.'),
+  })
+  .describe('A refusal from the model.')
 
 // src/gen/zod/summaryTextContentSchema.ts
-import { z as z58 } from "zod";
-var summaryTextContentSchema = z58.object({
-  "type": z58.enum(["summary_text"]).default("summary_text").describe("The type of the object. Always `summary_text`."),
-  "text": z58.string().describe("A summary of the reasoning output from the model so far.")
-}).describe("A summary text from the model.");
+import { z as z58 } from 'zod'
+var summaryTextContentSchema = z58
+  .object({
+    type: z58
+      .enum(['summary_text'])
+      .default('summary_text')
+      .describe('The type of the object. Always `summary_text`.'),
+    text: z58
+      .string()
+      .describe('A summary of the reasoning output from the model so far.'),
+  })
+  .describe('A summary text from the model.')
 
 // src/gen/zod/textContentSchema.ts
-import { z as z59 } from "zod";
-var textContentSchema = z59.object({
-  "type": z59.enum(["text"]).default("text"),
-  "text": z59.string()
-}).describe("A text content.");
+import { z as z59 } from 'zod'
+var textContentSchema = z59
+  .object({
+    type: z59.enum(['text']).default('text'),
+    text: z59.string(),
+  })
+  .describe('A text content.')
 
 // src/gen/zod/messageSchema.ts
-import { z as z60 } from "zod";
-var messageSchema = z60.object({
-  "type": z60.enum(["message"]).default("message").describe("The type of the message. Always set to `message`."),
-  "id": z60.string().describe("The unique ID of the message."),
-  "status": z60.lazy(() => messageStatusSchema).and(z60.any()),
-  "role": z60.lazy(() => messageRoleSchema).and(z60.any()),
-  "content": z60.array(z60.union([z60.lazy(() => inputTextContentSchema).and(z60.object({
-    "type": z60.literal("input_text")
-  })), z60.lazy(() => outputTextContentSchema).and(z60.object({
-    "type": z60.literal("output_text")
-  })), z60.lazy(() => textContentSchema).and(z60.object({
-    "type": z60.literal("text")
-  })), z60.lazy(() => summaryTextContentSchema).and(z60.object({
-    "type": z60.literal("summary_text")
-  })), z60.lazy(() => reasoningTextContentSchema).and(z60.object({
-    "type": z60.literal("reasoning_text")
-  })), z60.lazy(() => refusalContentSchema).and(z60.object({
-    "type": z60.literal("refusal")
-  })), z60.lazy(() => inputImageContentSchema).and(z60.object({
-    "type": z60.literal("input_image")
-  })), z60.lazy(() => inputFileContentSchema).and(z60.object({
-    "type": z60.literal("input_file")
-  })), z60.lazy(() => inputVideoContentSchema).and(z60.object({
-    "type": z60.literal("input_video")
-  }))]).describe("A content part that makes up an input or output item.")).describe("The content of the message")
-}).describe("A message to or from the model.");
+import { z as z60 } from 'zod'
+var messageSchema = z60
+  .object({
+    type: z60
+      .enum(['message'])
+      .default('message')
+      .describe('The type of the message. Always set to `message`.'),
+    id: z60.string().describe('The unique ID of the message.'),
+    status: z60.lazy(() => messageStatusSchema).and(z60.any()),
+    role: z60.lazy(() => messageRoleSchema).and(z60.any()),
+    content: z60
+      .array(
+        z60
+          .union([
+            z60
+              .lazy(() => inputTextContentSchema)
+              .and(
+                z60.object({
+                  type: z60.literal('input_text'),
+                }),
+              ),
+            z60
+              .lazy(() => outputTextContentSchema)
+              .and(
+                z60.object({
+                  type: z60.literal('output_text'),
+                }),
+              ),
+            z60
+              .lazy(() => textContentSchema)
+              .and(
+                z60.object({
+                  type: z60.literal('text'),
+                }),
+              ),
+            z60
+              .lazy(() => summaryTextContentSchema)
+              .and(
+                z60.object({
+                  type: z60.literal('summary_text'),
+                }),
+              ),
+            z60
+              .lazy(() => reasoningTextContentSchema)
+              .and(
+                z60.object({
+                  type: z60.literal('reasoning_text'),
+                }),
+              ),
+            z60
+              .lazy(() => refusalContentSchema)
+              .and(
+                z60.object({
+                  type: z60.literal('refusal'),
+                }),
+              ),
+            z60
+              .lazy(() => inputImageContentSchema)
+              .and(
+                z60.object({
+                  type: z60.literal('input_image'),
+                }),
+              ),
+            z60
+              .lazy(() => inputFileContentSchema)
+              .and(
+                z60.object({
+                  type: z60.literal('input_file'),
+                }),
+              ),
+            z60
+              .lazy(() => inputVideoContentSchema)
+              .and(
+                z60.object({
+                  type: z60.literal('input_video'),
+                }),
+              ),
+          ])
+          .describe('A content part that makes up an input or output item.'),
+      )
+      .describe('The content of the message'),
+  })
+  .describe('A message to or from the model.')
 
 // src/gen/zod/reasoningBodySchema.ts
-import { z as z61 } from "zod";
-var reasoningBodySchema = z61.object({
-  "type": z61.enum(["reasoning"]).default("reasoning").describe("The type of the item. Always `reasoning`."),
-  "id": z61.string().describe("The unique ID of the reasoning item."),
-  "content": z61.optional(z61.array(z61.union([z61.lazy(() => inputTextContentSchema).and(z61.object({
-    "type": z61.literal("input_text")
-  })), z61.lazy(() => outputTextContentSchema).and(z61.object({
-    "type": z61.literal("output_text")
-  })), z61.lazy(() => textContentSchema).and(z61.object({
-    "type": z61.literal("text")
-  })), z61.lazy(() => summaryTextContentSchema).and(z61.object({
-    "type": z61.literal("summary_text")
-  })), z61.lazy(() => reasoningTextContentSchema).and(z61.object({
-    "type": z61.literal("reasoning_text")
-  })), z61.lazy(() => refusalContentSchema).and(z61.object({
-    "type": z61.literal("refusal")
-  })), z61.lazy(() => inputImageContentSchema).and(z61.object({
-    "type": z61.literal("input_image")
-  })), z61.lazy(() => inputFileContentSchema).and(z61.object({
-    "type": z61.literal("input_file")
-  }))]).describe("A content part that makes up an input or output item.")).describe("The reasoning content that was generated.")),
-  "summary": z61.array(z61.union([z61.lazy(() => inputTextContentSchema).and(z61.object({
-    "type": z61.literal("input_text")
-  })), z61.lazy(() => outputTextContentSchema).and(z61.object({
-    "type": z61.literal("output_text")
-  })), z61.lazy(() => textContentSchema).and(z61.object({
-    "type": z61.literal("text")
-  })), z61.lazy(() => summaryTextContentSchema).and(z61.object({
-    "type": z61.literal("summary_text")
-  })), z61.lazy(() => reasoningTextContentSchema).and(z61.object({
-    "type": z61.literal("reasoning_text")
-  })), z61.lazy(() => refusalContentSchema).and(z61.object({
-    "type": z61.literal("refusal")
-  })), z61.lazy(() => inputImageContentSchema).and(z61.object({
-    "type": z61.literal("input_image")
-  })), z61.lazy(() => inputFileContentSchema).and(z61.object({
-    "type": z61.literal("input_file")
-  }))]).describe("A content part that makes up an input or output item.")).describe("The reasoning summary content that was generated."),
-  "encrypted_content": z61.optional(z61.string().describe("The encrypted reasoning content that was generated."))
-}).describe("A reasoning item that was generated by the model.");
+import { z as z61 } from 'zod'
+var reasoningBodySchema = z61
+  .object({
+    type: z61
+      .enum(['reasoning'])
+      .default('reasoning')
+      .describe('The type of the item. Always `reasoning`.'),
+    id: z61.string().describe('The unique ID of the reasoning item.'),
+    content: z61.optional(
+      z61
+        .array(
+          z61
+            .union([
+              z61
+                .lazy(() => inputTextContentSchema)
+                .and(
+                  z61.object({
+                    type: z61.literal('input_text'),
+                  }),
+                ),
+              z61
+                .lazy(() => outputTextContentSchema)
+                .and(
+                  z61.object({
+                    type: z61.literal('output_text'),
+                  }),
+                ),
+              z61
+                .lazy(() => textContentSchema)
+                .and(
+                  z61.object({
+                    type: z61.literal('text'),
+                  }),
+                ),
+              z61
+                .lazy(() => summaryTextContentSchema)
+                .and(
+                  z61.object({
+                    type: z61.literal('summary_text'),
+                  }),
+                ),
+              z61
+                .lazy(() => reasoningTextContentSchema)
+                .and(
+                  z61.object({
+                    type: z61.literal('reasoning_text'),
+                  }),
+                ),
+              z61
+                .lazy(() => refusalContentSchema)
+                .and(
+                  z61.object({
+                    type: z61.literal('refusal'),
+                  }),
+                ),
+              z61
+                .lazy(() => inputImageContentSchema)
+                .and(
+                  z61.object({
+                    type: z61.literal('input_image'),
+                  }),
+                ),
+              z61
+                .lazy(() => inputFileContentSchema)
+                .and(
+                  z61.object({
+                    type: z61.literal('input_file'),
+                  }),
+                ),
+            ])
+            .describe('A content part that makes up an input or output item.'),
+        )
+        .describe('The reasoning content that was generated.'),
+    ),
+    summary: z61
+      .array(
+        z61
+          .union([
+            z61
+              .lazy(() => inputTextContentSchema)
+              .and(
+                z61.object({
+                  type: z61.literal('input_text'),
+                }),
+              ),
+            z61
+              .lazy(() => outputTextContentSchema)
+              .and(
+                z61.object({
+                  type: z61.literal('output_text'),
+                }),
+              ),
+            z61
+              .lazy(() => textContentSchema)
+              .and(
+                z61.object({
+                  type: z61.literal('text'),
+                }),
+              ),
+            z61
+              .lazy(() => summaryTextContentSchema)
+              .and(
+                z61.object({
+                  type: z61.literal('summary_text'),
+                }),
+              ),
+            z61
+              .lazy(() => reasoningTextContentSchema)
+              .and(
+                z61.object({
+                  type: z61.literal('reasoning_text'),
+                }),
+              ),
+            z61
+              .lazy(() => refusalContentSchema)
+              .and(
+                z61.object({
+                  type: z61.literal('refusal'),
+                }),
+              ),
+            z61
+              .lazy(() => inputImageContentSchema)
+              .and(
+                z61.object({
+                  type: z61.literal('input_image'),
+                }),
+              ),
+            z61
+              .lazy(() => inputFileContentSchema)
+              .and(
+                z61.object({
+                  type: z61.literal('input_file'),
+                }),
+              ),
+          ])
+          .describe('A content part that makes up an input or output item.'),
+      )
+      .describe('The reasoning summary content that was generated.'),
+    encrypted_content: z61.optional(
+      z61
+        .string()
+        .describe('The encrypted reasoning content that was generated.'),
+    ),
+  })
+  .describe('A reasoning item that was generated by the model.')
 
 // src/gen/zod/itemFieldSchema.ts
-import { z as z62 } from "zod";
-var itemFieldSchema = z62.union([z62.lazy(() => messageSchema).and(z62.object({
-  "type": z62.literal("message")
-})), z62.lazy(() => functionCallSchema).and(z62.object({
-  "type": z62.literal("function_call")
-})), z62.lazy(() => functionCallOutputSchema).and(z62.object({
-  "type": z62.literal("function_call_output")
-})), z62.lazy(() => reasoningBodySchema).and(z62.object({
-  "type": z62.literal("reasoning")
-}))]).describe("An item representing a message, tool call, tool output, reasoning, or other response element.");
+import { z as z62 } from 'zod'
+var itemFieldSchema = z62
+  .union([
+    z62
+      .lazy(() => messageSchema)
+      .and(
+        z62.object({
+          type: z62.literal('message'),
+        }),
+      ),
+    z62
+      .lazy(() => functionCallSchema)
+      .and(
+        z62.object({
+          type: z62.literal('function_call'),
+        }),
+      ),
+    z62
+      .lazy(() => functionCallOutputSchema)
+      .and(
+        z62.object({
+          type: z62.literal('function_call_output'),
+        }),
+      ),
+    z62
+      .lazy(() => reasoningBodySchema)
+      .and(
+        z62.object({
+          type: z62.literal('reasoning'),
+        }),
+      ),
+  ])
+  .describe(
+    'An item representing a message, tool call, tool output, reasoning, or other response element.',
+  )
 
 // src/gen/zod/reasoningSchema.ts
-import { z as z63 } from "zod";
-var reasoningSchema = z63.object({
-  "effort": z63.union([z63.lazy(() => reasoningEffortEnumSchema), z63.null()]),
-  "summary": z63.union([z63.lazy(() => reasoningSummaryEnumSchema).and(z63.any()), z63.null()])
-}).describe("Reasoning configuration and metadata that were used for the response.");
+import { z as z63 } from 'zod'
+var reasoningSchema = z63
+  .object({
+    effort: z63.union([z63.lazy(() => reasoningEffortEnumSchema), z63.null()]),
+    summary: z63.union([
+      z63.lazy(() => reasoningSummaryEnumSchema).and(z63.any()),
+      z63.null(),
+    ]),
+  })
+  .describe(
+    'Reasoning configuration and metadata that were used for the response.',
+  )
 
 // src/gen/zod/jsonObjectResponseFormatSchema.ts
-import { z as z64 } from "zod";
+import { z as z64 } from 'zod'
 var jsonObjectResponseFormatSchema = z64.object({
-  "type": z64.enum(["json_object"]).default("json_object")
-});
+  type: z64.enum(['json_object']).default('json_object'),
+})
 
 // src/gen/zod/jsonSchemaResponseFormatSchema.ts
-import { z as z65 } from "zod";
+import { z as z65 } from 'zod'
 var jsonSchemaResponseFormatSchema = z65.object({
-  "type": z65.enum(["json_schema"]).default("json_schema"),
-  "name": z65.string(),
-  "description": z65.union([z65.string(), z65.null()]),
-  "schema": z65.null(),
-  "strict": z65.boolean()
-});
+  type: z65.enum(['json_schema']).default('json_schema'),
+  name: z65.string(),
+  description: z65.union([z65.string(), z65.null()]),
+  schema: z65.null(),
+  strict: z65.boolean(),
+})
 
 // src/gen/zod/textFieldSchema.ts
-import { z as z66 } from "zod";
+import { z as z66 } from 'zod'
 var textFieldSchema = z66.object({
-  "format": z66.union([z66.lazy(() => textResponseFormatSchema), z66.lazy(() => jsonObjectResponseFormatSchema), z66.lazy(() => jsonSchemaResponseFormatSchema)]),
-  "verbosity": z66.optional(z66.lazy(() => verbosityEnumSchema))
-});
+  format: z66.union([
+    z66.lazy(() => textResponseFormatSchema),
+    z66.lazy(() => jsonObjectResponseFormatSchema),
+    z66.lazy(() => jsonSchemaResponseFormatSchema),
+  ]),
+  verbosity: z66.optional(z66.lazy(() => verbosityEnumSchema)),
+})
 
 // src/gen/zod/functionToolSchema.ts
-import { z as z67 } from "zod";
-var functionToolSchema = z67.object({
-  "type": z67.enum(["function"]).default("function").describe("The type of the function tool. Always `function`."),
-  "name": z67.string().describe("The name of the function to call."),
-  "description": z67.union([z67.string(), z67.null()]),
-  "parameters": z67.union([z67.object({}).catchall(z67.any()), z67.null()]),
-  "strict": z67.union([z67.boolean(), z67.null()])
-}).describe("Defines a function in your own code the model can choose to call. Learn more about [function calling](https://platform.openai.com/docs/guides/function-calling).");
+import { z as z67 } from 'zod'
+var functionToolSchema = z67
+  .object({
+    type: z67
+      .enum(['function'])
+      .default('function')
+      .describe('The type of the function tool. Always `function`.'),
+    name: z67.string().describe('The name of the function to call.'),
+    description: z67.union([z67.string(), z67.null()]),
+    parameters: z67.union([z67.object({}).catchall(z67.any()), z67.null()]),
+    strict: z67.union([z67.boolean(), z67.null()]),
+  })
+  .describe(
+    'Defines a function in your own code the model can choose to call. Learn more about [function calling](https://platform.openai.com/docs/guides/function-calling).',
+  )
 
 // src/gen/zod/toolSchema.ts
-import { z as z68 } from "zod";
-var toolSchema = z68.lazy(() => functionToolSchema).and(z68.object({
-  "type": z68.literal("function")
-})).describe("A tool that can be used to generate a response.");
+import { z as z68 } from 'zod'
+var toolSchema = z68
+  .lazy(() => functionToolSchema)
+  .and(
+    z68.object({
+      type: z68.literal('function'),
+    }),
+  )
+  .describe('A tool that can be used to generate a response.')
 
 // src/gen/zod/inputTokensDetailsSchema.ts
-import { z as z69 } from "zod";
-var inputTokensDetailsSchema = z69.object({
-  "cached_tokens": z69.number().int().describe("The number of input tokens that were served from cache.")
-}).describe("A breakdown of input token usage that was recorded.");
+import { z as z69 } from 'zod'
+var inputTokensDetailsSchema = z69
+  .object({
+    cached_tokens: z69
+      .number()
+      .int()
+      .describe('The number of input tokens that were served from cache.'),
+  })
+  .describe('A breakdown of input token usage that was recorded.')
 
 // src/gen/zod/outputTokensDetailsSchema.ts
-import { z as z70 } from "zod";
-var outputTokensDetailsSchema = z70.object({
-  "reasoning_tokens": z70.number().int().describe("The number of output tokens that were attributed to reasoning.")
-}).describe("A breakdown of output token usage that was recorded.");
+import { z as z70 } from 'zod'
+var outputTokensDetailsSchema = z70
+  .object({
+    reasoning_tokens: z70
+      .number()
+      .int()
+      .describe(
+        'The number of output tokens that were attributed to reasoning.',
+      ),
+  })
+  .describe('A breakdown of output token usage that was recorded.')
 
 // src/gen/zod/usageSchema.ts
-import { z as z71 } from "zod";
-var usageSchema = z71.object({
-  "input_tokens": z71.number().int().describe("The number of input tokens that were used to generate the response."),
-  "output_tokens": z71.number().int().describe("The number of output tokens that were generated by the model."),
-  "total_tokens": z71.number().int().describe("The total number of tokens that were used."),
-  "input_tokens_details": z71.lazy(() => inputTokensDetailsSchema).and(z71.any()),
-  "output_tokens_details": z71.lazy(() => outputTokensDetailsSchema).and(z71.any())
-}).describe("Token usage statistics that were recorded for the response.");
+import { z as z71 } from 'zod'
+var usageSchema = z71
+  .object({
+    input_tokens: z71
+      .number()
+      .int()
+      .describe(
+        'The number of input tokens that were used to generate the response.',
+      ),
+    output_tokens: z71
+      .number()
+      .int()
+      .describe(
+        'The number of output tokens that were generated by the model.',
+      ),
+    total_tokens: z71
+      .number()
+      .int()
+      .describe('The total number of tokens that were used.'),
+    input_tokens_details: z71
+      .lazy(() => inputTokensDetailsSchema)
+      .and(z71.any()),
+    output_tokens_details: z71
+      .lazy(() => outputTokensDetailsSchema)
+      .and(z71.any()),
+  })
+  .describe('Token usage statistics that were recorded for the response.')
 
 // src/gen/zod/responseResourceSchema.ts
-import { z as z72 } from "zod";
-var responseResourceSchema = z72.object({
-  "id": z72.string().describe("The unique ID of the response that was created."),
-  "object": z72.enum(["response"]).default("response").describe("The object type, which was always `response`."),
-  "created_at": z72.number().int().describe("The Unix timestamp (in seconds) for when the response was created."),
-  "completed_at": z72.union([z72.number().int(), z72.null()]),
-  "status": z72.string().describe("The status that was set for the response."),
-  "incomplete_details": z72.union([z72.lazy(() => incompleteDetailsSchema).and(z72.any()), z72.null()]),
-  "model": z72.string().describe("The model that generated this response."),
-  "previous_response_id": z72.union([z72.string(), z72.null()]),
-  "instructions": z72.union([z72.string(), z72.null()]),
-  "output": z72.array(z72.lazy(() => itemFieldSchema).describe("An item representing a message, tool call, tool output, reasoning, or other response element.")).describe("The output items that were generated by the model."),
-  "error": z72.union([z72.lazy(() => errorSchema).and(z72.any()), z72.null()]),
-  "tools": z72.array(z72.lazy(() => toolSchema).describe("A tool that can be used to generate a response.")).describe("The tools that were available to the model during response generation."),
-  "tool_choice": z72.union([z72.lazy(() => functionToolChoiceSchema), z72.lazy(() => toolChoiceValueEnumSchema), z72.lazy(() => allowedToolChoiceSchema)]),
-  "truncation": z72.lazy(() => truncationEnumSchema).and(z72.any()),
-  "parallel_tool_calls": z72.boolean().describe("Whether the model was allowed to call multiple tools in parallel."),
-  "text": z72.lazy(() => textFieldSchema).and(z72.any()),
-  "top_p": z72.number().describe("The nucleus sampling parameter that was used for this response."),
-  "presence_penalty": z72.number().describe("The presence penalty that was used to penalize new tokens based on whether they appear in the text so far."),
-  "frequency_penalty": z72.number().describe("The frequency penalty that was used to penalize new tokens based on their frequency in the text so far."),
-  "top_logprobs": z72.number().int().describe("The number of most likely tokens that were returned at each position, along with their log probabilities."),
-  "temperature": z72.number().describe("The sampling temperature that was used for this response."),
-  "reasoning": z72.union([z72.lazy(() => reasoningSchema).and(z72.any()), z72.null()]),
-  "usage": z72.union([z72.lazy(() => usageSchema).and(z72.any()), z72.null()]),
-  "max_output_tokens": z72.union([z72.number().int(), z72.null()]),
-  "max_tool_calls": z72.union([z72.number().int(), z72.null()]),
-  "store": z72.boolean().describe("Whether this response was stored so it can be retrieved later."),
-  "background": z72.boolean().describe("Whether this request was run in the background."),
-  "service_tier": z72.string().describe("The service tier that was used for this response."),
-  "metadata": z72.any().describe("Developer-defined metadata that was associated with the response."),
-  "safety_identifier": z72.union([z72.string(), z72.null()]),
-  "prompt_cache_key": z72.union([z72.string(), z72.null()])
-}).describe("The complete response object that was returned by the Responses API.");
+import { z as z72 } from 'zod'
+var responseResourceSchema = z72
+  .object({
+    id: z72
+      .string()
+      .describe('The unique ID of the response that was created.'),
+    object: z72
+      .enum(['response'])
+      .default('response')
+      .describe('The object type, which was always `response`.'),
+    created_at: z72
+      .number()
+      .int()
+      .describe(
+        'The Unix timestamp (in seconds) for when the response was created.',
+      ),
+    completed_at: z72.union([z72.number().int(), z72.null()]),
+    status: z72.string().describe('The status that was set for the response.'),
+    incomplete_details: z72.union([
+      z72.lazy(() => incompleteDetailsSchema).and(z72.any()),
+      z72.null(),
+    ]),
+    model: z72.string().describe('The model that generated this response.'),
+    previous_response_id: z72.union([z72.string(), z72.null()]),
+    instructions: z72.union([z72.string(), z72.null()]),
+    output: z72
+      .array(
+        z72
+          .lazy(() => itemFieldSchema)
+          .describe(
+            'An item representing a message, tool call, tool output, reasoning, or other response element.',
+          ),
+      )
+      .describe('The output items that were generated by the model.'),
+    error: z72.union([z72.lazy(() => errorSchema).and(z72.any()), z72.null()]),
+    tools: z72
+      .array(
+        z72
+          .lazy(() => toolSchema)
+          .describe('A tool that can be used to generate a response.'),
+      )
+      .describe(
+        'The tools that were available to the model during response generation.',
+      ),
+    tool_choice: z72.union([
+      z72.lazy(() => functionToolChoiceSchema),
+      z72.lazy(() => toolChoiceValueEnumSchema),
+      z72.lazy(() => allowedToolChoiceSchema),
+    ]),
+    truncation: z72.lazy(() => truncationEnumSchema).and(z72.any()),
+    parallel_tool_calls: z72
+      .boolean()
+      .describe(
+        'Whether the model was allowed to call multiple tools in parallel.',
+      ),
+    text: z72.lazy(() => textFieldSchema).and(z72.any()),
+    top_p: z72
+      .number()
+      .describe(
+        'The nucleus sampling parameter that was used for this response.',
+      ),
+    presence_penalty: z72
+      .number()
+      .describe(
+        'The presence penalty that was used to penalize new tokens based on whether they appear in the text so far.',
+      ),
+    frequency_penalty: z72
+      .number()
+      .describe(
+        'The frequency penalty that was used to penalize new tokens based on their frequency in the text so far.',
+      ),
+    top_logprobs: z72
+      .number()
+      .int()
+      .describe(
+        'The number of most likely tokens that were returned at each position, along with their log probabilities.',
+      ),
+    temperature: z72
+      .number()
+      .describe('The sampling temperature that was used for this response.'),
+    reasoning: z72.union([
+      z72.lazy(() => reasoningSchema).and(z72.any()),
+      z72.null(),
+    ]),
+    usage: z72.union([z72.lazy(() => usageSchema).and(z72.any()), z72.null()]),
+    max_output_tokens: z72.union([z72.number().int(), z72.null()]),
+    max_tool_calls: z72.union([z72.number().int(), z72.null()]),
+    store: z72
+      .boolean()
+      .describe(
+        'Whether this response was stored so it can be retrieved later.',
+      ),
+    background: z72
+      .boolean()
+      .describe('Whether this request was run in the background.'),
+    service_tier: z72
+      .string()
+      .describe('The service tier that was used for this response.'),
+    metadata: z72
+      .any()
+      .describe(
+        'Developer-defined metadata that was associated with the response.',
+      ),
+    safety_identifier: z72.union([z72.string(), z72.null()]),
+    prompt_cache_key: z72.union([z72.string(), z72.null()]),
+  })
+  .describe(
+    'The complete response object that was returned by the Responses API.',
+  )
 
 // src/gen/zod/createresponseSchema.ts
-import { z as z73 } from "zod";
-var createresponse200Schema = z73.lazy(() => responseResourceSchema).describe("The complete response object that was returned by the Responses API.");
-var createresponseMutationRequestSchema = z73.lazy(() => createResponseBodySchema);
-var createresponseMutationResponseSchema = z73.lazy(() => createresponse200Schema);
+import { z as z73 } from 'zod'
+var createresponse200Schema = z73
+  .lazy(() => responseResourceSchema)
+  .describe(
+    'The complete response object that was returned by the Responses API.',
+  )
+var createresponseMutationRequestSchema = z73.lazy(
+  () => createResponseBodySchema,
+)
+var createresponseMutationResponseSchema = z73.lazy(
+  () => createresponse200Schema,
+)
 
 // src/gen/zod/detailEnumSchema.ts
-import { z as z74 } from "zod";
-var detailEnumSchema = z74.enum(["low", "high", "auto"]);
+import { z as z74 } from 'zod'
+var detailEnumSchema = z74.enum(['low', 'high', 'auto'])
 
 // src/gen/zod/developerMessageItemParamSchema.ts
-import { z as z75 } from "zod";
+import { z as z75 } from 'zod'
 var developerMessageItemParamSchema = z75.object({
-  "id": z75.optional(z75.union([z75.string(), z75.null()])),
-  "type": z75.enum(["message"]).default("message").describe("The item type. Always `message`."),
-  "role": z75.enum(["developer"]).default("developer").describe("The message role. Always `developer`."),
-  "content": z75.union([z75.array(z75.lazy(() => inputTextContentParamSchema).and(z75.object({
-    "type": z75.literal("input_text")
-  }))), z75.string()]).describe("The message content, as an array of content parts."),
-  "status": z75.optional(z75.union([z75.string(), z75.null()]))
-});
+  id: z75.optional(z75.union([z75.string(), z75.null()])),
+  type: z75
+    .enum(['message'])
+    .default('message')
+    .describe('The item type. Always `message`.'),
+  role: z75
+    .enum(['developer'])
+    .default('developer')
+    .describe('The message role. Always `developer`.'),
+  content: z75
+    .union([
+      z75.array(
+        z75
+          .lazy(() => inputTextContentParamSchema)
+          .and(
+            z75.object({
+              type: z75.literal('input_text'),
+            }),
+          ),
+      ),
+      z75.string(),
+    ])
+    .describe('The message content, as an array of content parts.'),
+  status: z75.optional(z75.union([z75.string(), z75.null()])),
+})
 
 // src/gen/zod/errorPayloadSchema.ts
-import { z as z76 } from "zod";
-var errorPayloadSchema = z76.object({
-  "type": z76.string().describe("The error type that was emitted."),
-  "code": z76.union([z76.string(), z76.null()]),
-  "message": z76.string().describe("The human-readable error message that was emitted."),
-  "param": z76.union([z76.string(), z76.null()]),
-  "headers": z76.optional(z76.object({}).catchall(z76.string().describe("The header value that was emitted.")).describe("The response headers that were emitted with the error, if any."))
-}).describe("An error payload that was emitted for a streaming error event.");
+import { z as z76 } from 'zod'
+var errorPayloadSchema = z76
+  .object({
+    type: z76.string().describe('The error type that was emitted.'),
+    code: z76.union([z76.string(), z76.null()]),
+    message: z76
+      .string()
+      .describe('The human-readable error message that was emitted.'),
+    param: z76.union([z76.string(), z76.null()]),
+    headers: z76.optional(
+      z76
+        .object({})
+        .catchall(z76.string().describe('The header value that was emitted.'))
+        .describe(
+          'The response headers that were emitted with the error, if any.',
+        ),
+    ),
+  })
+  .describe('An error payload that was emitted for a streaming error event.')
 
 // src/gen/zod/errorStreamingEventSchema.ts
-import { z as z77 } from "zod";
-var errorStreamingEventSchema = z77.object({
-  "type": z77.enum(["error"]).default("error").describe("The type of the event, always `error`."),
-  "sequence_number": z77.number().int().describe("The sequence number of the event that was emitted."),
-  "error": z77.lazy(() => errorPayloadSchema).and(z77.any())
-}).describe("A streaming event that indicated an error was emitted.");
+import { z as z77 } from 'zod'
+var errorStreamingEventSchema = z77
+  .object({
+    type: z77
+      .enum(['error'])
+      .default('error')
+      .describe('The type of the event, always `error`.'),
+    sequence_number: z77
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    error: z77.lazy(() => errorPayloadSchema).and(z77.any()),
+  })
+  .describe('A streaming event that indicated an error was emitted.')
 
 // src/gen/zod/functionCallItemStatusSchema.ts
-import { z as z78 } from "zod";
-var functionCallItemStatusSchema = z78.enum(["in_progress", "completed", "incomplete"]);
+import { z as z78 } from 'zod'
+var functionCallItemStatusSchema = z78.enum([
+  'in_progress',
+  'completed',
+  'incomplete',
+])
 
 // src/gen/zod/responseCompletedStreamingEventSchema.ts
-import { z as z79 } from "zod";
-var responseCompletedStreamingEventSchema = z79.object({
-  "type": z79.enum(["response.completed"]).default("response.completed").describe("The type of the event, always `response.completed`."),
-  "sequence_number": z79.number().int().describe("The sequence number of the event that was emitted."),
-  "response": z79.lazy(() => responseResourceSchema).and(z79.any())
-}).describe("A streaming event that indicated the response was completed.");
+import { z as z79 } from 'zod'
+var responseCompletedStreamingEventSchema = z79
+  .object({
+    type: z79
+      .enum(['response.completed'])
+      .default('response.completed')
+      .describe('The type of the event, always `response.completed`.'),
+    sequence_number: z79
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    response: z79.lazy(() => responseResourceSchema).and(z79.any()),
+  })
+  .describe('A streaming event that indicated the response was completed.')
 
 // src/gen/zod/responseContentPartAddedStreamingEventSchema.ts
-import { z as z80 } from "zod";
-var responseContentPartAddedStreamingEventSchema = z80.object({
-  "type": z80.enum(["response.content_part.added"]).default("response.content_part.added").describe("The type of the event, always `response.content_part.added`."),
-  "sequence_number": z80.number().int().describe("The sequence number of the event that was emitted."),
-  "item_id": z80.string().describe("The ID of the item that was updated."),
-  "output_index": z80.number().int().describe("The index of the output item that was updated."),
-  "content_index": z80.number().int().describe("The index of the content part that was added."),
-  "part": z80.union([z80.lazy(() => inputTextContentSchema).and(z80.object({
-    "type": z80.literal("input_text")
-  })), z80.lazy(() => outputTextContentSchema).and(z80.object({
-    "type": z80.literal("output_text")
-  })), z80.lazy(() => textContentSchema).and(z80.object({
-    "type": z80.literal("text")
-  })), z80.lazy(() => summaryTextContentSchema).and(z80.object({
-    "type": z80.literal("summary_text")
-  })), z80.lazy(() => reasoningTextContentSchema).and(z80.object({
-    "type": z80.literal("reasoning_text")
-  })), z80.lazy(() => refusalContentSchema).and(z80.object({
-    "type": z80.literal("refusal")
-  })), z80.lazy(() => inputImageContentSchema).and(z80.object({
-    "type": z80.literal("input_image")
-  })), z80.lazy(() => inputFileContentSchema).and(z80.object({
-    "type": z80.literal("input_file")
-  }))]).describe("A content part that makes up an input or output item.")
-}).describe("A streaming event that indicated a content part was added.");
+import { z as z80 } from 'zod'
+var responseContentPartAddedStreamingEventSchema = z80
+  .object({
+    type: z80
+      .enum(['response.content_part.added'])
+      .default('response.content_part.added')
+      .describe('The type of the event, always `response.content_part.added`.'),
+    sequence_number: z80
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    item_id: z80.string().describe('The ID of the item that was updated.'),
+    output_index: z80
+      .number()
+      .int()
+      .describe('The index of the output item that was updated.'),
+    content_index: z80
+      .number()
+      .int()
+      .describe('The index of the content part that was added.'),
+    part: z80
+      .union([
+        z80
+          .lazy(() => inputTextContentSchema)
+          .and(
+            z80.object({
+              type: z80.literal('input_text'),
+            }),
+          ),
+        z80
+          .lazy(() => outputTextContentSchema)
+          .and(
+            z80.object({
+              type: z80.literal('output_text'),
+            }),
+          ),
+        z80
+          .lazy(() => textContentSchema)
+          .and(
+            z80.object({
+              type: z80.literal('text'),
+            }),
+          ),
+        z80
+          .lazy(() => summaryTextContentSchema)
+          .and(
+            z80.object({
+              type: z80.literal('summary_text'),
+            }),
+          ),
+        z80
+          .lazy(() => reasoningTextContentSchema)
+          .and(
+            z80.object({
+              type: z80.literal('reasoning_text'),
+            }),
+          ),
+        z80
+          .lazy(() => refusalContentSchema)
+          .and(
+            z80.object({
+              type: z80.literal('refusal'),
+            }),
+          ),
+        z80
+          .lazy(() => inputImageContentSchema)
+          .and(
+            z80.object({
+              type: z80.literal('input_image'),
+            }),
+          ),
+        z80
+          .lazy(() => inputFileContentSchema)
+          .and(
+            z80.object({
+              type: z80.literal('input_file'),
+            }),
+          ),
+      ])
+      .describe('A content part that makes up an input or output item.'),
+  })
+  .describe('A streaming event that indicated a content part was added.')
 
 // src/gen/zod/responseContentPartDoneStreamingEventSchema.ts
-import { z as z81 } from "zod";
-var responseContentPartDoneStreamingEventSchema = z81.object({
-  "type": z81.enum(["response.content_part.done"]).default("response.content_part.done").describe("The type of the event, always `response.content_part.done`."),
-  "sequence_number": z81.number().int().describe("The sequence number of the event that was emitted."),
-  "item_id": z81.string().describe("The ID of the item that was updated."),
-  "output_index": z81.number().int().describe("The index of the output item that was updated."),
-  "content_index": z81.number().int().describe("The index of the content part that was completed."),
-  "part": z81.union([z81.lazy(() => inputTextContentSchema).and(z81.object({
-    "type": z81.literal("input_text")
-  })), z81.lazy(() => outputTextContentSchema).and(z81.object({
-    "type": z81.literal("output_text")
-  })), z81.lazy(() => textContentSchema).and(z81.object({
-    "type": z81.literal("text")
-  })), z81.lazy(() => summaryTextContentSchema).and(z81.object({
-    "type": z81.literal("summary_text")
-  })), z81.lazy(() => reasoningTextContentSchema).and(z81.object({
-    "type": z81.literal("reasoning_text")
-  })), z81.lazy(() => refusalContentSchema).and(z81.object({
-    "type": z81.literal("refusal")
-  })), z81.lazy(() => inputImageContentSchema).and(z81.object({
-    "type": z81.literal("input_image")
-  })), z81.lazy(() => inputFileContentSchema).and(z81.object({
-    "type": z81.literal("input_file")
-  }))]).describe("A content part that makes up an input or output item.")
-}).describe("A streaming event that indicated a content part was completed.");
+import { z as z81 } from 'zod'
+var responseContentPartDoneStreamingEventSchema = z81
+  .object({
+    type: z81
+      .enum(['response.content_part.done'])
+      .default('response.content_part.done')
+      .describe('The type of the event, always `response.content_part.done`.'),
+    sequence_number: z81
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    item_id: z81.string().describe('The ID of the item that was updated.'),
+    output_index: z81
+      .number()
+      .int()
+      .describe('The index of the output item that was updated.'),
+    content_index: z81
+      .number()
+      .int()
+      .describe('The index of the content part that was completed.'),
+    part: z81
+      .union([
+        z81
+          .lazy(() => inputTextContentSchema)
+          .and(
+            z81.object({
+              type: z81.literal('input_text'),
+            }),
+          ),
+        z81
+          .lazy(() => outputTextContentSchema)
+          .and(
+            z81.object({
+              type: z81.literal('output_text'),
+            }),
+          ),
+        z81
+          .lazy(() => textContentSchema)
+          .and(
+            z81.object({
+              type: z81.literal('text'),
+            }),
+          ),
+        z81
+          .lazy(() => summaryTextContentSchema)
+          .and(
+            z81.object({
+              type: z81.literal('summary_text'),
+            }),
+          ),
+        z81
+          .lazy(() => reasoningTextContentSchema)
+          .and(
+            z81.object({
+              type: z81.literal('reasoning_text'),
+            }),
+          ),
+        z81
+          .lazy(() => refusalContentSchema)
+          .and(
+            z81.object({
+              type: z81.literal('refusal'),
+            }),
+          ),
+        z81
+          .lazy(() => inputImageContentSchema)
+          .and(
+            z81.object({
+              type: z81.literal('input_image'),
+            }),
+          ),
+        z81
+          .lazy(() => inputFileContentSchema)
+          .and(
+            z81.object({
+              type: z81.literal('input_file'),
+            }),
+          ),
+      ])
+      .describe('A content part that makes up an input or output item.'),
+  })
+  .describe('A streaming event that indicated a content part was completed.')
 
 // src/gen/zod/responseCreatedStreamingEventSchema.ts
-import { z as z82 } from "zod";
-var responseCreatedStreamingEventSchema = z82.object({
-  "type": z82.enum(["response.created"]).default("response.created").describe("The type of the event, always `response.created`."),
-  "sequence_number": z82.number().int().describe("The sequence number of the event that was emitted."),
-  "response": z82.lazy(() => responseResourceSchema).and(z82.any())
-}).describe("A streaming event that indicated the response was created.");
+import { z as z82 } from 'zod'
+var responseCreatedStreamingEventSchema = z82
+  .object({
+    type: z82
+      .enum(['response.created'])
+      .default('response.created')
+      .describe('The type of the event, always `response.created`.'),
+    sequence_number: z82
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    response: z82.lazy(() => responseResourceSchema).and(z82.any()),
+  })
+  .describe('A streaming event that indicated the response was created.')
 
 // src/gen/zod/responseFailedStreamingEventSchema.ts
-import { z as z83 } from "zod";
-var responseFailedStreamingEventSchema = z83.object({
-  "type": z83.enum(["response.failed"]).default("response.failed").describe("The type of the event, always `response.failed`."),
-  "sequence_number": z83.number().int().describe("The sequence number of the event that was emitted."),
-  "response": z83.lazy(() => responseResourceSchema).and(z83.any())
-}).describe("A streaming event that indicated the response had failed.");
+import { z as z83 } from 'zod'
+var responseFailedStreamingEventSchema = z83
+  .object({
+    type: z83
+      .enum(['response.failed'])
+      .default('response.failed')
+      .describe('The type of the event, always `response.failed`.'),
+    sequence_number: z83
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    response: z83.lazy(() => responseResourceSchema).and(z83.any()),
+  })
+  .describe('A streaming event that indicated the response had failed.')
 
 // src/gen/zod/responseFunctionCallArgumentsDeltaStreamingEventSchema.ts
-import { z as z84 } from "zod";
-var responseFunctionCallArgumentsDeltaStreamingEventSchema = z84.object({
-  "type": z84.enum(["response.function_call_arguments.delta"]).default("response.function_call_arguments.delta").describe("The type of the event, always `response.function_call_arguments.delta`."),
-  "sequence_number": z84.number().int().describe("The sequence number of the event that was emitted."),
-  "item_id": z84.string().describe("The ID of the tool call item that was updated."),
-  "output_index": z84.number().int().describe("The index of the output item that was updated."),
-  "delta": z84.string().describe("The arguments delta that was appended."),
-  "obfuscation": z84.optional(z84.string().describe("An obfuscation string that was added to pad the event payload."))
-}).describe("A streaming event that indicated function call arguments were incrementally added.");
+import { z as z84 } from 'zod'
+var responseFunctionCallArgumentsDeltaStreamingEventSchema = z84
+  .object({
+    type: z84
+      .enum(['response.function_call_arguments.delta'])
+      .default('response.function_call_arguments.delta')
+      .describe(
+        'The type of the event, always `response.function_call_arguments.delta`.',
+      ),
+    sequence_number: z84
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    item_id: z84
+      .string()
+      .describe('The ID of the tool call item that was updated.'),
+    output_index: z84
+      .number()
+      .int()
+      .describe('The index of the output item that was updated.'),
+    delta: z84.string().describe('The arguments delta that was appended.'),
+    obfuscation: z84.optional(
+      z84
+        .string()
+        .describe(
+          'An obfuscation string that was added to pad the event payload.',
+        ),
+    ),
+  })
+  .describe(
+    'A streaming event that indicated function call arguments were incrementally added.',
+  )
 
 // src/gen/zod/responseFunctionCallArgumentsDoneStreamingEventSchema.ts
-import { z as z85 } from "zod";
-var responseFunctionCallArgumentsDoneStreamingEventSchema = z85.object({
-  "type": z85.enum(["response.function_call_arguments.done"]).default("response.function_call_arguments.done").describe("The type of the event, always `response.function_call_arguments.done`."),
-  "sequence_number": z85.number().int().describe("The sequence number of the event that was emitted."),
-  "item_id": z85.string().describe("The ID of the tool call item that was updated."),
-  "output_index": z85.number().int().describe("The index of the output item that was updated."),
-  "arguments": z85.string().describe("The final arguments string that was emitted.")
-}).describe("A streaming event that indicated function call arguments were completed.");
+import { z as z85 } from 'zod'
+var responseFunctionCallArgumentsDoneStreamingEventSchema = z85
+  .object({
+    type: z85
+      .enum(['response.function_call_arguments.done'])
+      .default('response.function_call_arguments.done')
+      .describe(
+        'The type of the event, always `response.function_call_arguments.done`.',
+      ),
+    sequence_number: z85
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    item_id: z85
+      .string()
+      .describe('The ID of the tool call item that was updated.'),
+    output_index: z85
+      .number()
+      .int()
+      .describe('The index of the output item that was updated.'),
+    arguments: z85
+      .string()
+      .describe('The final arguments string that was emitted.'),
+  })
+  .describe(
+    'A streaming event that indicated function call arguments were completed.',
+  )
 
 // src/gen/zod/responseIncompleteStreamingEventSchema.ts
-import { z as z86 } from "zod";
-var responseIncompleteStreamingEventSchema = z86.object({
-  "type": z86.enum(["response.incomplete"]).default("response.incomplete").describe("The type of the event, always `response.incomplete`."),
-  "sequence_number": z86.number().int().describe("The sequence number of the event that was emitted."),
-  "response": z86.lazy(() => responseResourceSchema).and(z86.any())
-}).describe("A streaming event that indicated the response was incomplete.");
+import { z as z86 } from 'zod'
+var responseIncompleteStreamingEventSchema = z86
+  .object({
+    type: z86
+      .enum(['response.incomplete'])
+      .default('response.incomplete')
+      .describe('The type of the event, always `response.incomplete`.'),
+    sequence_number: z86
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    response: z86.lazy(() => responseResourceSchema).and(z86.any()),
+  })
+  .describe('A streaming event that indicated the response was incomplete.')
 
 // src/gen/zod/responseInProgressStreamingEventSchema.ts
-import { z as z87 } from "zod";
-var responseInProgressStreamingEventSchema = z87.object({
-  "type": z87.enum(["response.in_progress"]).default("response.in_progress").describe("The type of the event, always `response.in_progress`."),
-  "sequence_number": z87.number().int().describe("The sequence number of the event that was emitted."),
-  "response": z87.lazy(() => responseResourceSchema).and(z87.any())
-}).describe("A streaming event that indicated the response was in progress.");
+import { z as z87 } from 'zod'
+var responseInProgressStreamingEventSchema = z87
+  .object({
+    type: z87
+      .enum(['response.in_progress'])
+      .default('response.in_progress')
+      .describe('The type of the event, always `response.in_progress`.'),
+    sequence_number: z87
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    response: z87.lazy(() => responseResourceSchema).and(z87.any()),
+  })
+  .describe('A streaming event that indicated the response was in progress.')
 
 // src/gen/zod/responseOutputItemAddedStreamingEventSchema.ts
-import { z as z88 } from "zod";
-var responseOutputItemAddedStreamingEventSchema = z88.object({
-  "type": z88.enum(["response.output_item.added"]).default("response.output_item.added").describe("The type of the event, always `response.output_item.added`."),
-  "sequence_number": z88.number().int().describe("The sequence number of the event that was emitted."),
-  "output_index": z88.number().int().describe("The index of the output item that was added."),
-  "item": z88.union([z88.lazy(() => itemFieldSchema).and(z88.any()), z88.null()])
-}).describe("A streaming event that indicated an output item was added to the response.");
+import { z as z88 } from 'zod'
+var responseOutputItemAddedStreamingEventSchema = z88
+  .object({
+    type: z88
+      .enum(['response.output_item.added'])
+      .default('response.output_item.added')
+      .describe('The type of the event, always `response.output_item.added`.'),
+    sequence_number: z88
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    output_index: z88
+      .number()
+      .int()
+      .describe('The index of the output item that was added.'),
+    item: z88.union([
+      z88.lazy(() => itemFieldSchema).and(z88.any()),
+      z88.null(),
+    ]),
+  })
+  .describe(
+    'A streaming event that indicated an output item was added to the response.',
+  )
 
 // src/gen/zod/responseOutputItemDoneStreamingEventSchema.ts
-import { z as z89 } from "zod";
-var responseOutputItemDoneStreamingEventSchema = z89.object({
-  "type": z89.enum(["response.output_item.done"]).default("response.output_item.done").describe("The type of the event, always `response.output_item.done`."),
-  "sequence_number": z89.number().int().describe("The sequence number of the event that was emitted."),
-  "output_index": z89.number().int().describe("The index of the output item that was completed."),
-  "item": z89.union([z89.lazy(() => itemFieldSchema).and(z89.any()), z89.null()])
-}).describe("A streaming event that indicated an output item was completed.");
+import { z as z89 } from 'zod'
+var responseOutputItemDoneStreamingEventSchema = z89
+  .object({
+    type: z89
+      .enum(['response.output_item.done'])
+      .default('response.output_item.done')
+      .describe('The type of the event, always `response.output_item.done`.'),
+    sequence_number: z89
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    output_index: z89
+      .number()
+      .int()
+      .describe('The index of the output item that was completed.'),
+    item: z89.union([
+      z89.lazy(() => itemFieldSchema).and(z89.any()),
+      z89.null(),
+    ]),
+  })
+  .describe('A streaming event that indicated an output item was completed.')
 
 // src/gen/zod/responseOutputTextAnnotationAddedStreamingEventSchema.ts
-import { z as z90 } from "zod";
-var responseOutputTextAnnotationAddedStreamingEventSchema = z90.object({
-  "type": z90.enum(["response.output_text.annotation.added"]).default("response.output_text.annotation.added").describe("The type of the event, always `response.output_text.annotation.added`."),
-  "sequence_number": z90.number().int().describe("The sequence number of the event that was emitted."),
-  "item_id": z90.string().describe("The ID of the item that was updated."),
-  "output_index": z90.number().int().describe("The index of the output item that was updated."),
-  "content_index": z90.number().int().describe("The index of the output text content that was updated."),
-  "annotation_index": z90.number().int().describe("The index of the annotation that was added."),
-  "annotation": z90.union([z90.lazy(() => annotationSchema).and(z90.any()), z90.null()])
-}).describe("A streaming event that indicated an output text annotation was added.");
+import { z as z90 } from 'zod'
+var responseOutputTextAnnotationAddedStreamingEventSchema = z90
+  .object({
+    type: z90
+      .enum(['response.output_text.annotation.added'])
+      .default('response.output_text.annotation.added')
+      .describe(
+        'The type of the event, always `response.output_text.annotation.added`.',
+      ),
+    sequence_number: z90
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    item_id: z90.string().describe('The ID of the item that was updated.'),
+    output_index: z90
+      .number()
+      .int()
+      .describe('The index of the output item that was updated.'),
+    content_index: z90
+      .number()
+      .int()
+      .describe('The index of the output text content that was updated.'),
+    annotation_index: z90
+      .number()
+      .int()
+      .describe('The index of the annotation that was added.'),
+    annotation: z90.union([
+      z90.lazy(() => annotationSchema).and(z90.any()),
+      z90.null(),
+    ]),
+  })
+  .describe(
+    'A streaming event that indicated an output text annotation was added.',
+  )
 
 // src/gen/zod/responseOutputTextDeltaStreamingEventSchema.ts
-import { z as z91 } from "zod";
-var responseOutputTextDeltaStreamingEventSchema = z91.object({
-  "type": z91.enum(["response.output_text.delta"]).default("response.output_text.delta").describe("The type of the event, always `response.output_text.delta`."),
-  "sequence_number": z91.number().int().describe("The sequence number of the event that was emitted."),
-  "item_id": z91.string().describe("The ID of the item that was updated."),
-  "output_index": z91.number().int().describe("The index of the output item that was updated."),
-  "content_index": z91.number().int().describe("The index of the content part that was updated."),
-  "delta": z91.string().describe("The text delta that was appended."),
-  "logprobs": z91.array(z91.lazy(() => logProbSchema).describe("The log probability of a token.")).describe("The token log probabilities that were emitted with the delta, if any."),
-  "obfuscation": z91.optional(z91.string().describe("An obfuscation string that was added to pad the event payload."))
-}).describe("A streaming event that indicated output text was incrementally added.");
+import { z as z91 } from 'zod'
+var responseOutputTextDeltaStreamingEventSchema = z91
+  .object({
+    type: z91
+      .enum(['response.output_text.delta'])
+      .default('response.output_text.delta')
+      .describe('The type of the event, always `response.output_text.delta`.'),
+    sequence_number: z91
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    item_id: z91.string().describe('The ID of the item that was updated.'),
+    output_index: z91
+      .number()
+      .int()
+      .describe('The index of the output item that was updated.'),
+    content_index: z91
+      .number()
+      .int()
+      .describe('The index of the content part that was updated.'),
+    delta: z91.string().describe('The text delta that was appended.'),
+    logprobs: z91
+      .array(
+        z91
+          .lazy(() => logProbSchema)
+          .describe('The log probability of a token.'),
+      )
+      .describe(
+        'The token log probabilities that were emitted with the delta, if any.',
+      ),
+    obfuscation: z91.optional(
+      z91
+        .string()
+        .describe(
+          'An obfuscation string that was added to pad the event payload.',
+        ),
+    ),
+  })
+  .describe(
+    'A streaming event that indicated output text was incrementally added.',
+  )
 
 // src/gen/zod/responseOutputTextDoneStreamingEventSchema.ts
-import { z as z92 } from "zod";
-var responseOutputTextDoneStreamingEventSchema = z92.object({
-  "type": z92.enum(["response.output_text.done"]).default("response.output_text.done").describe("The type of the event, always `response.output_text.done`."),
-  "sequence_number": z92.number().int().describe("The sequence number of the event that was emitted."),
-  "item_id": z92.string().describe("The ID of the item that was updated."),
-  "output_index": z92.number().int().describe("The index of the output item that was updated."),
-  "content_index": z92.number().int().describe("The index of the content part that was completed."),
-  "text": z92.string().describe("The final text that was emitted."),
-  "logprobs": z92.array(z92.lazy(() => logProbSchema).describe("The log probability of a token.")).describe("The token log probabilities that were emitted with the final text, if any.")
-}).describe("A streaming event that indicated output text was completed.");
+import { z as z92 } from 'zod'
+var responseOutputTextDoneStreamingEventSchema = z92
+  .object({
+    type: z92
+      .enum(['response.output_text.done'])
+      .default('response.output_text.done')
+      .describe('The type of the event, always `response.output_text.done`.'),
+    sequence_number: z92
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    item_id: z92.string().describe('The ID of the item that was updated.'),
+    output_index: z92
+      .number()
+      .int()
+      .describe('The index of the output item that was updated.'),
+    content_index: z92
+      .number()
+      .int()
+      .describe('The index of the content part that was completed.'),
+    text: z92.string().describe('The final text that was emitted.'),
+    logprobs: z92
+      .array(
+        z92
+          .lazy(() => logProbSchema)
+          .describe('The log probability of a token.'),
+      )
+      .describe(
+        'The token log probabilities that were emitted with the final text, if any.',
+      ),
+  })
+  .describe('A streaming event that indicated output text was completed.')
 
 // src/gen/zod/responseQueuedStreamingEventSchema.ts
-import { z as z93 } from "zod";
-var responseQueuedStreamingEventSchema = z93.object({
-  "type": z93.enum(["response.queued"]).default("response.queued").describe("The type of the event, always `response.queued`."),
-  "sequence_number": z93.number().int().describe("The sequence number of the event that was emitted."),
-  "response": z93.lazy(() => responseResourceSchema).and(z93.any())
-}).describe("A streaming event that indicated the response was queued.");
+import { z as z93 } from 'zod'
+var responseQueuedStreamingEventSchema = z93
+  .object({
+    type: z93
+      .enum(['response.queued'])
+      .default('response.queued')
+      .describe('The type of the event, always `response.queued`.'),
+    sequence_number: z93
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    response: z93.lazy(() => responseResourceSchema).and(z93.any()),
+  })
+  .describe('A streaming event that indicated the response was queued.')
 
 // src/gen/zod/responseReasoningDeltaStreamingEventSchema.ts
-import { z as z94 } from "zod";
-var responseReasoningDeltaStreamingEventSchema = z94.object({
-  "type": z94.enum(["response.reasoning.delta"]).default("response.reasoning.delta").describe("The type of the event, always `response.reasoning.delta`."),
-  "sequence_number": z94.number().int().describe("The sequence number of the event that was emitted."),
-  "item_id": z94.string().describe("The ID of the item that was updated."),
-  "output_index": z94.number().int().describe("The index of the output item that was updated."),
-  "content_index": z94.number().int().describe("The index of the reasoning content that was updated."),
-  "delta": z94.string().describe("The reasoning text delta that was appended."),
-  "obfuscation": z94.optional(z94.string().describe("An obfuscation string that was added to pad the event payload."))
-}).describe("A streaming event that indicated reasoning text was incrementally added.");
+import { z as z94 } from 'zod'
+var responseReasoningDeltaStreamingEventSchema = z94
+  .object({
+    type: z94
+      .enum(['response.reasoning.delta'])
+      .default('response.reasoning.delta')
+      .describe('The type of the event, always `response.reasoning.delta`.'),
+    sequence_number: z94
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    item_id: z94.string().describe('The ID of the item that was updated.'),
+    output_index: z94
+      .number()
+      .int()
+      .describe('The index of the output item that was updated.'),
+    content_index: z94
+      .number()
+      .int()
+      .describe('The index of the reasoning content that was updated.'),
+    delta: z94.string().describe('The reasoning text delta that was appended.'),
+    obfuscation: z94.optional(
+      z94
+        .string()
+        .describe(
+          'An obfuscation string that was added to pad the event payload.',
+        ),
+    ),
+  })
+  .describe(
+    'A streaming event that indicated reasoning text was incrementally added.',
+  )
 
 // src/gen/zod/responseReasoningDoneStreamingEventSchema.ts
-import { z as z95 } from "zod";
-var responseReasoningDoneStreamingEventSchema = z95.object({
-  "type": z95.enum(["response.reasoning.done"]).default("response.reasoning.done").describe("The type of the event, always `response.reasoning.done`."),
-  "sequence_number": z95.number().int().describe("The sequence number of the event that was emitted."),
-  "item_id": z95.string().describe("The ID of the item that was updated."),
-  "output_index": z95.number().int().describe("The index of the output item that was updated."),
-  "content_index": z95.number().int().describe("The index of the reasoning content that was completed."),
-  "text": z95.string().describe("The final reasoning text that was emitted.")
-}).describe("A streaming event that indicated reasoning text was completed.");
+import { z as z95 } from 'zod'
+var responseReasoningDoneStreamingEventSchema = z95
+  .object({
+    type: z95
+      .enum(['response.reasoning.done'])
+      .default('response.reasoning.done')
+      .describe('The type of the event, always `response.reasoning.done`.'),
+    sequence_number: z95
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    item_id: z95.string().describe('The ID of the item that was updated.'),
+    output_index: z95
+      .number()
+      .int()
+      .describe('The index of the output item that was updated.'),
+    content_index: z95
+      .number()
+      .int()
+      .describe('The index of the reasoning content that was completed.'),
+    text: z95.string().describe('The final reasoning text that was emitted.'),
+  })
+  .describe('A streaming event that indicated reasoning text was completed.')
 
 // src/gen/zod/responseReasoningSummaryDeltaStreamingEventSchema.ts
-import { z as z96 } from "zod";
-var responseReasoningSummaryDeltaStreamingEventSchema = z96.object({
-  "type": z96.enum(["response.reasoning_summary_text.delta"]).default("response.reasoning_summary_text.delta").describe("The type of the event, always `response.reasoning_summary.delta`."),
-  "sequence_number": z96.number().int().describe("The sequence number of the event that was emitted."),
-  "item_id": z96.string().describe("The ID of the item that was updated."),
-  "output_index": z96.number().int().describe("The index of the output item that was updated."),
-  "summary_index": z96.number().int().describe("The index of the summary content that was updated."),
-  "delta": z96.string().describe("The summary text delta that was appended."),
-  "obfuscation": z96.optional(z96.string().describe("An obfuscation string that was added to pad the event payload."))
-}).describe("A streaming event that indicated a reasoning summary was incrementally added.");
+import { z as z96 } from 'zod'
+var responseReasoningSummaryDeltaStreamingEventSchema = z96
+  .object({
+    type: z96
+      .enum(['response.reasoning_summary_text.delta'])
+      .default('response.reasoning_summary_text.delta')
+      .describe(
+        'The type of the event, always `response.reasoning_summary.delta`.',
+      ),
+    sequence_number: z96
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    item_id: z96.string().describe('The ID of the item that was updated.'),
+    output_index: z96
+      .number()
+      .int()
+      .describe('The index of the output item that was updated.'),
+    summary_index: z96
+      .number()
+      .int()
+      .describe('The index of the summary content that was updated.'),
+    delta: z96.string().describe('The summary text delta that was appended.'),
+    obfuscation: z96.optional(
+      z96
+        .string()
+        .describe(
+          'An obfuscation string that was added to pad the event payload.',
+        ),
+    ),
+  })
+  .describe(
+    'A streaming event that indicated a reasoning summary was incrementally added.',
+  )
 
 // src/gen/zod/responseReasoningSummaryDoneStreamingEventSchema.ts
-import { z as z97 } from "zod";
-var responseReasoningSummaryDoneStreamingEventSchema = z97.object({
-  "type": z97.enum(["response.reasoning_summary_text.done"]).default("response.reasoning_summary_text.done").describe("The type of the event, always `response.reasoning_summary.done`."),
-  "sequence_number": z97.number().int().describe("The sequence number of the event that was emitted."),
-  "item_id": z97.string().describe("The ID of the item that was updated."),
-  "output_index": z97.number().int().describe("The index of the output item that was updated."),
-  "summary_index": z97.number().int().describe("The index of the summary content that was completed."),
-  "text": z97.string().describe("The final summary text that was emitted.")
-}).describe("A streaming event that indicated a reasoning summary was completed.");
+import { z as z97 } from 'zod'
+var responseReasoningSummaryDoneStreamingEventSchema = z97
+  .object({
+    type: z97
+      .enum(['response.reasoning_summary_text.done'])
+      .default('response.reasoning_summary_text.done')
+      .describe(
+        'The type of the event, always `response.reasoning_summary.done`.',
+      ),
+    sequence_number: z97
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    item_id: z97.string().describe('The ID of the item that was updated.'),
+    output_index: z97
+      .number()
+      .int()
+      .describe('The index of the output item that was updated.'),
+    summary_index: z97
+      .number()
+      .int()
+      .describe('The index of the summary content that was completed.'),
+    text: z97.string().describe('The final summary text that was emitted.'),
+  })
+  .describe(
+    'A streaming event that indicated a reasoning summary was completed.',
+  )
 
 // src/gen/zod/responseReasoningSummaryPartAddedStreamingEventSchema.ts
-import { z as z98 } from "zod";
-var responseReasoningSummaryPartAddedStreamingEventSchema = z98.object({
-  "type": z98.enum(["response.reasoning_summary_part.added"]).default("response.reasoning_summary_part.added").describe("The type of the event, always `response.reasoning_summary_part.added`."),
-  "sequence_number": z98.number().int().describe("The sequence number of the event that was emitted."),
-  "item_id": z98.string().describe("The ID of the item that was updated."),
-  "output_index": z98.number().int().describe("The index of the output item that was updated."),
-  "summary_index": z98.number().int().describe("The index of the summary part that was added."),
-  "part": z98.union([z98.lazy(() => inputTextContentSchema).and(z98.object({
-    "type": z98.literal("input_text")
-  })), z98.lazy(() => outputTextContentSchema).and(z98.object({
-    "type": z98.literal("output_text")
-  })), z98.lazy(() => textContentSchema).and(z98.object({
-    "type": z98.literal("text")
-  })), z98.lazy(() => summaryTextContentSchema).and(z98.object({
-    "type": z98.literal("summary_text")
-  })), z98.lazy(() => reasoningTextContentSchema).and(z98.object({
-    "type": z98.literal("reasoning_text")
-  })), z98.lazy(() => refusalContentSchema).and(z98.object({
-    "type": z98.literal("refusal")
-  })), z98.lazy(() => inputImageContentSchema).and(z98.object({
-    "type": z98.literal("input_image")
-  })), z98.lazy(() => inputFileContentSchema).and(z98.object({
-    "type": z98.literal("input_file")
-  }))]).describe("A content part that makes up an input or output item.")
-}).describe("A streaming event that indicated a reasoning summary part was added.");
+import { z as z98 } from 'zod'
+var responseReasoningSummaryPartAddedStreamingEventSchema = z98
+  .object({
+    type: z98
+      .enum(['response.reasoning_summary_part.added'])
+      .default('response.reasoning_summary_part.added')
+      .describe(
+        'The type of the event, always `response.reasoning_summary_part.added`.',
+      ),
+    sequence_number: z98
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    item_id: z98.string().describe('The ID of the item that was updated.'),
+    output_index: z98
+      .number()
+      .int()
+      .describe('The index of the output item that was updated.'),
+    summary_index: z98
+      .number()
+      .int()
+      .describe('The index of the summary part that was added.'),
+    part: z98
+      .union([
+        z98
+          .lazy(() => inputTextContentSchema)
+          .and(
+            z98.object({
+              type: z98.literal('input_text'),
+            }),
+          ),
+        z98
+          .lazy(() => outputTextContentSchema)
+          .and(
+            z98.object({
+              type: z98.literal('output_text'),
+            }),
+          ),
+        z98
+          .lazy(() => textContentSchema)
+          .and(
+            z98.object({
+              type: z98.literal('text'),
+            }),
+          ),
+        z98
+          .lazy(() => summaryTextContentSchema)
+          .and(
+            z98.object({
+              type: z98.literal('summary_text'),
+            }),
+          ),
+        z98
+          .lazy(() => reasoningTextContentSchema)
+          .and(
+            z98.object({
+              type: z98.literal('reasoning_text'),
+            }),
+          ),
+        z98
+          .lazy(() => refusalContentSchema)
+          .and(
+            z98.object({
+              type: z98.literal('refusal'),
+            }),
+          ),
+        z98
+          .lazy(() => inputImageContentSchema)
+          .and(
+            z98.object({
+              type: z98.literal('input_image'),
+            }),
+          ),
+        z98
+          .lazy(() => inputFileContentSchema)
+          .and(
+            z98.object({
+              type: z98.literal('input_file'),
+            }),
+          ),
+      ])
+      .describe('A content part that makes up an input or output item.'),
+  })
+  .describe(
+    'A streaming event that indicated a reasoning summary part was added.',
+  )
 
 // src/gen/zod/responseReasoningSummaryPartDoneStreamingEventSchema.ts
-import { z as z99 } from "zod";
-var responseReasoningSummaryPartDoneStreamingEventSchema = z99.object({
-  "type": z99.enum(["response.reasoning_summary_part.done"]).default("response.reasoning_summary_part.done").describe("The type of the event, always `response.reasoning_summary_part.done`."),
-  "sequence_number": z99.number().int().describe("The sequence number of the event that was emitted."),
-  "item_id": z99.string().describe("The ID of the item that was updated."),
-  "output_index": z99.number().int().describe("The index of the output item that was updated."),
-  "summary_index": z99.number().int().describe("The index of the summary part that was completed."),
-  "part": z99.union([z99.lazy(() => inputTextContentSchema).and(z99.object({
-    "type": z99.literal("input_text")
-  })), z99.lazy(() => outputTextContentSchema).and(z99.object({
-    "type": z99.literal("output_text")
-  })), z99.lazy(() => textContentSchema).and(z99.object({
-    "type": z99.literal("text")
-  })), z99.lazy(() => summaryTextContentSchema).and(z99.object({
-    "type": z99.literal("summary_text")
-  })), z99.lazy(() => reasoningTextContentSchema).and(z99.object({
-    "type": z99.literal("reasoning_text")
-  })), z99.lazy(() => refusalContentSchema).and(z99.object({
-    "type": z99.literal("refusal")
-  })), z99.lazy(() => inputImageContentSchema).and(z99.object({
-    "type": z99.literal("input_image")
-  })), z99.lazy(() => inputFileContentSchema).and(z99.object({
-    "type": z99.literal("input_file")
-  }))]).describe("A content part that makes up an input or output item.")
-}).describe("A streaming event that indicated a reasoning summary part was completed.");
+import { z as z99 } from 'zod'
+var responseReasoningSummaryPartDoneStreamingEventSchema = z99
+  .object({
+    type: z99
+      .enum(['response.reasoning_summary_part.done'])
+      .default('response.reasoning_summary_part.done')
+      .describe(
+        'The type of the event, always `response.reasoning_summary_part.done`.',
+      ),
+    sequence_number: z99
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    item_id: z99.string().describe('The ID of the item that was updated.'),
+    output_index: z99
+      .number()
+      .int()
+      .describe('The index of the output item that was updated.'),
+    summary_index: z99
+      .number()
+      .int()
+      .describe('The index of the summary part that was completed.'),
+    part: z99
+      .union([
+        z99
+          .lazy(() => inputTextContentSchema)
+          .and(
+            z99.object({
+              type: z99.literal('input_text'),
+            }),
+          ),
+        z99
+          .lazy(() => outputTextContentSchema)
+          .and(
+            z99.object({
+              type: z99.literal('output_text'),
+            }),
+          ),
+        z99
+          .lazy(() => textContentSchema)
+          .and(
+            z99.object({
+              type: z99.literal('text'),
+            }),
+          ),
+        z99
+          .lazy(() => summaryTextContentSchema)
+          .and(
+            z99.object({
+              type: z99.literal('summary_text'),
+            }),
+          ),
+        z99
+          .lazy(() => reasoningTextContentSchema)
+          .and(
+            z99.object({
+              type: z99.literal('reasoning_text'),
+            }),
+          ),
+        z99
+          .lazy(() => refusalContentSchema)
+          .and(
+            z99.object({
+              type: z99.literal('refusal'),
+            }),
+          ),
+        z99
+          .lazy(() => inputImageContentSchema)
+          .and(
+            z99.object({
+              type: z99.literal('input_image'),
+            }),
+          ),
+        z99
+          .lazy(() => inputFileContentSchema)
+          .and(
+            z99.object({
+              type: z99.literal('input_file'),
+            }),
+          ),
+      ])
+      .describe('A content part that makes up an input or output item.'),
+  })
+  .describe(
+    'A streaming event that indicated a reasoning summary part was completed.',
+  )
 
 // src/gen/zod/responseRefusalDeltaStreamingEventSchema.ts
-import { z as z100 } from "zod";
-var responseRefusalDeltaStreamingEventSchema = z100.object({
-  "type": z100.enum(["response.refusal.delta"]).default("response.refusal.delta").describe("The type of the event, always `response.refusal.delta`."),
-  "sequence_number": z100.number().int().describe("The sequence number of the event that was emitted."),
-  "item_id": z100.string().describe("The ID of the item that was updated."),
-  "output_index": z100.number().int().describe("The index of the output item that was updated."),
-  "content_index": z100.number().int().describe("The index of the refusal content that was updated."),
-  "delta": z100.string().describe("The refusal text delta that was appended.")
-}).describe("A streaming event that indicated refusal text was incrementally added.");
+import { z as z100 } from 'zod'
+var responseRefusalDeltaStreamingEventSchema = z100
+  .object({
+    type: z100
+      .enum(['response.refusal.delta'])
+      .default('response.refusal.delta')
+      .describe('The type of the event, always `response.refusal.delta`.'),
+    sequence_number: z100
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    item_id: z100.string().describe('The ID of the item that was updated.'),
+    output_index: z100
+      .number()
+      .int()
+      .describe('The index of the output item that was updated.'),
+    content_index: z100
+      .number()
+      .int()
+      .describe('The index of the refusal content that was updated.'),
+    delta: z100.string().describe('The refusal text delta that was appended.'),
+  })
+  .describe(
+    'A streaming event that indicated refusal text was incrementally added.',
+  )
 
 // src/gen/zod/responseRefusalDoneStreamingEventSchema.ts
-import { z as z101 } from "zod";
-var responseRefusalDoneStreamingEventSchema = z101.object({
-  "type": z101.enum(["response.refusal.done"]).default("response.refusal.done").describe("The type of the event, always `response.refusal.done`."),
-  "sequence_number": z101.number().int().describe("The sequence number of the event that was emitted."),
-  "item_id": z101.string().describe("The ID of the item that was updated."),
-  "output_index": z101.number().int().describe("The index of the output item that was updated."),
-  "content_index": z101.number().int().describe("The index of the refusal content that was completed."),
-  "refusal": z101.string().describe("The final refusal text that was emitted.")
-}).describe("A streaming event that indicated refusal text was completed.");
+import { z as z101 } from 'zod'
+var responseRefusalDoneStreamingEventSchema = z101
+  .object({
+    type: z101
+      .enum(['response.refusal.done'])
+      .default('response.refusal.done')
+      .describe('The type of the event, always `response.refusal.done`.'),
+    sequence_number: z101
+      .number()
+      .int()
+      .describe('The sequence number of the event that was emitted.'),
+    item_id: z101.string().describe('The ID of the item that was updated.'),
+    output_index: z101
+      .number()
+      .int()
+      .describe('The index of the output item that was updated.'),
+    content_index: z101
+      .number()
+      .int()
+      .describe('The index of the refusal content that was completed.'),
+    refusal: z101.string().describe('The final refusal text that was emitted.'),
+  })
+  .describe('A streaming event that indicated refusal text was completed.')
 
 // src/gen/zod/systemMessageItemParamSchema.ts
-import { z as z102 } from "zod";
+import { z as z102 } from 'zod'
 var systemMessageItemParamSchema = z102.object({
-  "id": z102.optional(z102.union([z102.string(), z102.null()])),
-  "type": z102.enum(["message"]).default("message").describe("The item type. Always `message`."),
-  "role": z102.enum(["system"]).default("system").describe("The message role. Always `system`."),
-  "content": z102.union([z102.array(z102.lazy(() => inputTextContentParamSchema).and(z102.object({
-    "type": z102.literal("input_text")
-  }))), z102.string()]).describe("The message content, as an array of content parts."),
-  "status": z102.optional(z102.union([z102.string(), z102.null()]))
-});
+  id: z102.optional(z102.union([z102.string(), z102.null()])),
+  type: z102
+    .enum(['message'])
+    .default('message')
+    .describe('The item type. Always `message`.'),
+  role: z102
+    .enum(['system'])
+    .default('system')
+    .describe('The message role. Always `system`.'),
+  content: z102
+    .union([
+      z102.array(
+        z102
+          .lazy(() => inputTextContentParamSchema)
+          .and(
+            z102.object({
+              type: z102.literal('input_text'),
+            }),
+          ),
+      ),
+      z102.string(),
+    ])
+    .describe('The message content, as an array of content parts.'),
+  status: z102.optional(z102.union([z102.string(), z102.null()])),
+})
 
 // src/gen/zod/userMessageItemParamSchema.ts
-import { z as z103 } from "zod";
+import { z as z103 } from 'zod'
 var userMessageItemParamSchema = z103.object({
-  "id": z103.optional(z103.union([z103.string(), z103.null()])),
-  "type": z103.enum(["message"]).default("message").describe("The item type. Always `message`."),
-  "role": z103.enum(["user"]).default("user").describe("The message role. Always `user`."),
-  "content": z103.union([z103.array(z103.union([z103.lazy(() => inputTextContentParamSchema).and(z103.object({
-    "type": z103.literal("input_text")
-  })), z103.lazy(() => inputImageContentParamAutoParamSchema).and(z103.object({
-    "type": z103.literal("input_image")
-  })), z103.lazy(() => inputFileContentParamSchema).and(z103.object({
-    "type": z103.literal("input_file")
-  }))]).describe("A piece of message content, such as text, an image, or a file.")), z103.string()]).describe("The message content, as an array of content parts."),
-  "status": z103.optional(z103.union([z103.string(), z103.null()]))
-});
+  id: z103.optional(z103.union([z103.string(), z103.null()])),
+  type: z103
+    .enum(['message'])
+    .default('message')
+    .describe('The item type. Always `message`.'),
+  role: z103
+    .enum(['user'])
+    .default('user')
+    .describe('The message role. Always `user`.'),
+  content: z103
+    .union([
+      z103.array(
+        z103
+          .union([
+            z103
+              .lazy(() => inputTextContentParamSchema)
+              .and(
+                z103.object({
+                  type: z103.literal('input_text'),
+                }),
+              ),
+            z103
+              .lazy(() => inputImageContentParamAutoParamSchema)
+              .and(
+                z103.object({
+                  type: z103.literal('input_image'),
+                }),
+              ),
+            z103
+              .lazy(() => inputFileContentParamSchema)
+              .and(
+                z103.object({
+                  type: z103.literal('input_file'),
+                }),
+              ),
+          ])
+          .describe(
+            'A piece of message content, such as text, an image, or a file.',
+          ),
+      ),
+      z103.string(),
+    ])
+    .describe('The message content, as an array of content parts.'),
+  status: z103.optional(z103.union([z103.string(), z103.null()])),
+})
 
 // src/client.ts
 var TekimaxResponse = class {
   constructor(_raw) {
-    this._raw = _raw;
+    this._raw = _raw
   }
   /**
    * Access the raw response object returned by the API.
    */
   get raw() {
-    return this._raw;
+    return this._raw
   }
   /**
    * Automatically extracts the text content from the response.
    * It looks for the first "output_text" item in the response content.
    */
   get text() {
-    if (!this._raw.output) return void 0;
+    if (!this._raw.output) return void 0
     for (const item of this._raw.output) {
-      if (item.type === "message") {
+      if (item.type === 'message') {
         for (const contentPart of item.content) {
-          if (contentPart.type === "output_text" || contentPart.type === "text") {
-            return contentPart.text;
+          if (
+            contentPart.type === 'output_text' ||
+            contentPart.type === 'text'
+          ) {
+            return contentPart.text
           }
         }
       }
     }
-    return void 0;
+    return void 0
   }
   /**
    * The ID of the response.
    */
   get id() {
-    return this._raw.id ?? void 0;
+    return this._raw.id ?? void 0
   }
   /**
    * The model used to generate the response.
    */
   get model() {
-    return this._raw.model ?? void 0;
+    return this._raw.model ?? void 0
   }
-};
+}
 var TekimaxClient = class {
   /**
    * Creates a new TekimaxClient.
-   * 
+   *
    * @param options - Configuration options for the client.
    * @param options.baseUrl - The base URL of the API (default: "https://api.tekimax.com").
    * @param options.apiKey - Your Tekimax API key.
-   * 
+   *
    * @example
    * const client = new TekimaxClient({ apiKey: "tm_..." });
    */
   constructor(options = {}) {
-    this.baseUrl = options.baseUrl || "https://api.tekimax.com";
+    this.baseUrl = options.baseUrl || 'https://api.tekimax.com'
     this.headers = {
-      "Content-Type": "application/json",
-      ...options.apiKey ? { "Authorization": `Bearer ${options.apiKey}` } : {}
-    };
+      'Content-Type': 'application/json',
+      ...(options.apiKey ? { Authorization: `Bearer ${options.apiKey}` } : {}),
+    }
   }
   async request(path, body) {
     const response = await fetch(`${this.baseUrl}${path}`, {
-      method: "POST",
+      method: 'POST',
       headers: this.headers,
-      body: JSON.stringify(body)
-    });
+      body: JSON.stringify(body),
+    })
     if (!response.ok) {
-      throw new Error(`Tekimax API Error: ${response.status} ${response.statusText}`);
+      throw new Error(
+        `Tekimax API Error: ${response.status} ${response.statusText}`,
+      )
     }
-    const data = await response.json();
-    return new TekimaxResponse(data);
+    const data = await response.json()
+    return new TekimaxResponse(data)
   }
   /**
    * Creates a new session and sends the initial message.
-   * 
+   *
    * @param message - The initial message text to start the session.
    * @param options - Additional configuration options (model, temperature, etc.).
-   * 
+   *
    * @example
    * const response = await client.createSession("Hello, world!", { model: "gpt-4" });
    * console.log(response.text);
@@ -1369,26 +2800,26 @@ var TekimaxClient = class {
   async createSession(message, options) {
     const body = {
       ...options,
-      input: message
-    };
-    return this.request("/responses", body);
+      input: message,
+    }
+    return this.request('/responses', body)
   }
   /**
    * Sends a message to an existing session or starts a new one if no previous_response_id is provided.
-   * 
+   *
    * @param message - The message text to send.
    * @param options - Additional configuration options.
-   * 
+   *
    * @example
-   * const response = await client.sendMessage("What is the weather?", { 
-   *   previous_response_id: "resp_123" 
+   * const response = await client.sendMessage("What is the weather?", {
+   *   previous_response_id: "resp_123"
    * });
    * console.log(response.text);
    */
   async sendMessage(message, options) {
-    return this.createSession(message, options);
+    return this.createSession(message, options)
   }
-};
+}
 export {
   TekimaxClient,
   TekimaxResponse,
@@ -1578,5 +3009,5 @@ export {
   userMessageItemParamSchema,
   userMessageItemParamTypeEnum,
   verbosityEnumEnum,
-  verbosityEnumSchema
-};
+  verbosityEnumSchema,
+}