@ai-sdk/openai 4.0.65 → 4.0.67

package/dist/index.js

@@ -918,9 +918,119 @@ var openaiLanguageModelChatOptions = lazySchema2(
 );
 
 // src/chat/openai-chat-prepare-tools.ts
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
+} from "@ai-sdk/provider";
+
+// src/normalize-openai-json-schema.ts
 import {
   UnsupportedFunctionalityError as UnsupportedFunctionalityError2
 } from "@ai-sdk/provider";
+function normalizeOpenAIJsonSchema(schema) {
+  let removedPropertyNames = false;
+  const normalizedSchema = normalizeSchema(schema);
+  return {
+    schema: normalizedSchema,
+    warnings: removedPropertyNames ? [
+      {
+        type: "compatibility",
+        feature: "JSON Schema propertyNames",
+        details: "OpenAI does not support JSON Schema propertyNames. It was removed before sending the schema, so OpenAI will not enforce property-name constraints."
+      }
+    ] : []
+  };
+  function normalizeSchema(schema2) {
+    const propertyNames = schema2.propertyNames;
+    if (propertyNames != null) {
+      if (typeof propertyNames === "boolean" || propertyNames.type !== "string") {
+        throw new UnsupportedFunctionalityError2({
+          functionality: "JSON Schema propertyNames that does not use a string schema"
+        });
+      }
+      removedPropertyNames = true;
+    }
+    const normalizedSchema2 = { ...schema2 };
+    delete normalizedSchema2.propertyNames;
+    if (normalizedSchema2.properties != null) {
+      normalizedSchema2.properties = normalizeSchemaRecord(
+        normalizedSchema2.properties
+      );
+    }
+    if (normalizedSchema2.patternProperties != null) {
+      normalizedSchema2.patternProperties = normalizeSchemaRecord(
+        normalizedSchema2.patternProperties
+      );
+    }
+    if (normalizedSchema2.additionalProperties != null) {
+      normalizedSchema2.additionalProperties = normalizeDefinition(
+        normalizedSchema2.additionalProperties
+      );
+    }
+    if (normalizedSchema2.additionalItems != null) {
+      normalizedSchema2.additionalItems = normalizeDefinition(
+        normalizedSchema2.additionalItems
+      );
+    }
+    if (normalizedSchema2.items != null) {
+      normalizedSchema2.items = Array.isArray(normalizedSchema2.items) ? normalizedSchema2.items.map(normalizeDefinition) : normalizeDefinition(normalizedSchema2.items);
+    }
+    if (normalizedSchema2.contains != null) {
+      normalizedSchema2.contains = normalizeDefinition(
+        normalizedSchema2.contains
+      );
+    }
+    if (normalizedSchema2.not != null) {
+      normalizedSchema2.not = normalizeDefinition(normalizedSchema2.not);
+    }
+    if (normalizedSchema2.allOf != null) {
+      normalizedSchema2.allOf = normalizedSchema2.allOf.map(normalizeDefinition);
+    }
+    if (normalizedSchema2.anyOf != null) {
+      normalizedSchema2.anyOf = normalizedSchema2.anyOf.map(normalizeDefinition);
+    }
+    if (normalizedSchema2.oneOf != null) {
+      normalizedSchema2.oneOf = normalizedSchema2.oneOf.map(normalizeDefinition);
+    }
+    if (normalizedSchema2.definitions != null) {
+      normalizedSchema2.definitions = normalizeSchemaRecord(
+        normalizedSchema2.definitions
+      );
+    }
+    if (normalizedSchema2.$defs != null) {
+      normalizedSchema2.$defs = normalizeSchemaRecord(normalizedSchema2.$defs);
+    }
+    if (normalizedSchema2.dependencies != null) {
+      normalizedSchema2.dependencies = Object.fromEntries(
+        Object.entries(normalizedSchema2.dependencies).map(
+          ([key, dependency]) => [
+            key,
+            Array.isArray(dependency) ? dependency : normalizeDefinition(dependency)
+          ]
+        )
+      );
+    }
+    for (const keyword of ["if", "then", "else"]) {
+      const conditionalSchema = normalizedSchema2[keyword];
+      if (conditionalSchema != null) {
+        normalizedSchema2[keyword] = normalizeDefinition(conditionalSchema);
+      }
+    }
+    return normalizedSchema2;
+  }
+  function normalizeSchemaRecord(schemas) {
+    return Object.fromEntries(
+      Object.entries(schemas).map(([key, schema2]) => [
+        key,
+        normalizeDefinition(schema2)
+      ])
+    );
+  }
+  function normalizeDefinition(definition) {
+    return typeof definition === "boolean" ? definition : normalizeSchema(definition);
+  }
+}
+
+// src/chat/openai-chat-prepare-tools.ts
 function prepareChatTools({
   tools,
   toolChoice
@@ -933,17 +1043,22 @@ function prepareChatTools({
   const openaiTools2 = [];
   for (const tool of tools) {
     switch (tool.type) {
-      case "function":
+      case "function": {
+        const normalizedInputSchema = normalizeOpenAIJsonSchema(
+          tool.inputSchema
+        );
+        toolWarnings.push(...normalizedInputSchema.warnings);
         openaiTools2.push({
           type: "function",
           function: {
             name: tool.name,
             description: tool.description,
-            parameters: tool.inputSchema,
+            parameters: normalizedInputSchema.schema,
             ...tool.strict != null ? { strict: tool.strict } : {}
           }
         });
         break;
+      }
       default:
         toolWarnings.push({
           type: "unsupported",
@@ -974,7 +1089,7 @@ function prepareChatTools({
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new UnsupportedFunctionalityError2({
+      throw new UnsupportedFunctionalityError3({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -1050,6 +1165,10 @@ var OpenAIChatLanguageModel = class _OpenAIChatLanguageModel {
     );
     warnings.push(...messageWarnings);
     const strictJsonSchema = (_e = openaiOptions.strictJsonSchema) != null ? _e : true;
+    const normalizedResponseFormatSchema = (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null ? normalizeOpenAIJsonSchema(responseFormat.schema) : void 0;
+    if (normalizedResponseFormatSchema != null) {
+      warnings.push(...normalizedResponseFormatSchema.warnings);
+    }
     const baseArgs = {
       // model id:
       model: this.modelId,
@@ -1065,10 +1184,10 @@ var OpenAIChatLanguageModel = class _OpenAIChatLanguageModel {
       top_p: topP,
       frequency_penalty: frequencyPenalty,
       presence_penalty: presencePenalty,
-      response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? responseFormat.schema != null ? {
+      response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? normalizedResponseFormatSchema != null ? {
         type: "json_schema",
         json_schema: {
-          schema: responseFormat.schema,
+          schema: normalizedResponseFormatSchema.schema,
           strict: strictJsonSchema,
           name: (_f = responseFormat.name) != null ? _f : "response",
           description: responseFormat.description
@@ -1485,7 +1604,7 @@ function convertOpenAICompletionUsage(usage) {
 // src/completion/convert-to-openai-completion-prompt.ts
 import {
   InvalidPromptError,
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError4
 } from "@ai-sdk/provider";
 function convertToOpenAICompletionPrompt({
   prompt,
@@ -1528,7 +1647,7 @@ ${userMessage}
               return part.text;
             }
             case "tool-call": {
-              throw new UnsupportedFunctionalityError3({
+              throw new UnsupportedFunctionalityError4({
                 functionality: "tool-call messages"
               });
             }
@@ -1541,7 +1660,7 @@ ${assistantMessage}
         break;
       }
       case "tool": {
-        throw new UnsupportedFunctionalityError3({
+        throw new UnsupportedFunctionalityError4({
           functionality: "tool messages"
         });
       }
@@ -3562,7 +3681,8 @@ var openaiTools = {
 // src/openai-batch.ts
 import {
   InvalidArgumentError as InvalidArgumentError2,
-  InvalidResponseDataError as InvalidResponseDataError2
+  InvalidResponseDataError as InvalidResponseDataError2,
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError7
 } from "@ai-sdk/provider";
 import {
   combineHeaders as combineHeaders7,
@@ -4723,7 +4843,7 @@ function prepareOpenAIConfigForWorkflowDeserialize(config) {
 
 // src/responses/convert-to-openai-responses-input.ts
 import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError4
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError5
 } from "@ai-sdk/provider";
 import {
   convertToBase64 as convertToBase642,
@@ -5143,7 +5263,7 @@ async function convertToOpenAIResponsesInput({
                     };
                   }
                   case "text": {
-                    throw new UnsupportedFunctionalityError4({
+                    throw new UnsupportedFunctionalityError5({
                       functionality: "text file parts"
                     });
                   }
@@ -5173,7 +5293,7 @@ async function convertToOpenAIResponsesInput({
                       }
                       const fullMediaType = resolveFullMediaType2({ part });
                       if (fullMediaType !== "application/pdf" && !passThroughUnsupportedFiles) {
-                        throw new UnsupportedFunctionalityError4({
+                        throw new UnsupportedFunctionalityError5({
                           functionality: `file part media type ${fullMediaType}`
                         });
                       }
@@ -5909,7 +6029,7 @@ ${text}`,
           }
           const resultCaller = (_P = (_O = part.providerOptions) == null ? void 0 : _O[providerOptionsName]) == null ? void 0 : _P.caller;
           if (output.type === "execution-denied" && ((resultCaller == null ? void 0 : resultCaller.type) === "program" || programmaticToolCallIds.has(part.toolCallId))) {
-            throw new UnsupportedFunctionalityError4({
+            throw new UnsupportedFunctionalityError5({
               functionality: "execution-denied results for programmatic tool calls"
             });
           }
@@ -6060,6 +6180,14 @@ var openaiLanguageModelResponsesOptionsSchema = lazySchema25(
           "message.output_text.logprobs"
         ])
       ).nullish(),
+      /**
+       * Whether to automatically include web search action sources in the
+       * response. Disable this for OpenAI-compatible providers that do not
+       * support the `web_search_call.action.sources` include value.
+       *
+       * Defaults to `true`.
+       */
+      includeWebSearchSources: z27.boolean().optional(),
       /**
        * Instructions for the model.
        * They can be used to change the system or developer message when continuing a conversation using the `previousResponseId` option.
@@ -6259,7 +6387,7 @@ var openaiLanguageModelResponsesOptionsSchema = lazySchema25(
 
 // src/responses/openai-responses-prepare-tools.ts
 import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError5
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError6
 } from "@ai-sdk/provider";
 import {
   resolveProviderReference as resolveProviderReference3,
@@ -6307,6 +6435,7 @@ async function prepareResponsesTools({
         const openaiFunctionTool = prepareFunctionTool({
           tool,
           options: openaiOptions,
+          toolWarnings,
           async: resolveAsyncToolOption({
             value: openaiOptions == null ? void 0 : openaiOptions.async,
             supportsAsyncToolCalling,
@@ -6329,7 +6458,7 @@ async function prepareResponsesTools({
             namespaceTools.set(namespace.name, namespaceTool);
             openaiTools2.push(namespaceTool);
           } else if (namespaceTool.description !== namespace.description) {
-            throw new UnsupportedFunctionalityError5({
+            throw new UnsupportedFunctionalityError6({
               functionality: `conflicting descriptions for OpenAI tool namespace "${namespace.name}"`
             });
           }
@@ -6596,7 +6725,7 @@ async function prepareResponsesTools({
       allowedToolEntries.push(resolution.entry);
     }
     if (allowedToolEntries.length === 0) {
-      throw new UnsupportedFunctionalityError5({
+      throw new UnsupportedFunctionalityError6({
         functionality: `allowedTools with only tools that cannot be allow-listed (${droppedToolNames.join(
           ", "
         )})`
@@ -6631,7 +6760,7 @@ async function prepareResponsesTools({
     }
     default: {
       const _exhaustiveCheck = type;
-      throw new UnsupportedFunctionalityError5({
+      throw new UnsupportedFunctionalityError6({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -6687,19 +6816,27 @@ function toAllowedToolResolution(tool) {
 function prepareFunctionTool({
   tool,
   options,
+  toolWarnings,
   async
 }) {
+  var _a2;
   const deferLoading = options == null ? void 0 : options.deferLoading;
+  const normalizedInputSchema = normalizeOpenAIJsonSchema(tool.inputSchema);
+  const normalizedOutputSchema = (options == null ? void 0 : options.outputSchema) != null ? normalizeOpenAIJsonSchema(options.outputSchema) : void 0;
+  toolWarnings.push(
+    ...normalizedInputSchema.warnings,
+    ...(_a2 = normalizedOutputSchema == null ? void 0 : normalizedOutputSchema.warnings) != null ? _a2 : []
+  );
   return {
     type: "function",
     name: tool.name,
     description: tool.description,
-    parameters: tool.inputSchema,
+    parameters: normalizedInputSchema.schema,
     ...async != null ? { async } : {},
     ...tool.strict != null ? { strict: tool.strict } : {},
     ...deferLoading != null ? { defer_loading: deferLoading } : {},
     ...(options == null ? void 0 : options.allowedCallers) != null ? { allowed_callers: options.allowedCallers } : {},
-    ...(options == null ? void 0 : options.outputSchema) != null ? { output_schema: options.outputSchema } : {}
+    ...(options == null ? void 0 : options.outputSchema) != null ? { output_schema: normalizedOutputSchema == null ? void 0 : normalizedOutputSchema.schema } : {}
   };
 }
 function resolveAsyncToolOption({
@@ -7022,6 +7159,10 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
       input.push({ type: "compaction_trigger" });
     }
     const strictJsonSchema = (_g = openaiOptions == null ? void 0 : openaiOptions.strictJsonSchema) != null ? _g : true;
+    const normalizedResponseFormatSchema = (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null ? normalizeOpenAIJsonSchema(responseFormat.schema) : void 0;
+    if (normalizedResponseFormatSchema != null) {
+      warnings.push(...normalizedResponseFormatSchema.warnings);
+    }
     let include = openaiOptions == null ? void 0 : openaiOptions.include;
     function addInclude(key) {
       if (include == null) {
@@ -7044,7 +7185,7 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
     const webSearchToolName = (_h = tools == null ? void 0 : tools.find(
       (tool) => tool.type === "provider" && (tool.id === "openai.web_search" || tool.id === "openai.web_search_preview")
     )) == null ? void 0 : _h.name;
-    if (webSearchToolName) {
+    if (webSearchToolName && config.supportsWebSearchSourcesInclude !== false && (openaiOptions == null ? void 0 : openaiOptions.includeWebSearchSources) !== false) {
       addInclude("web_search_call.action.sources");
     }
     if (hasOpenAITool("openai.code_interpreter")) {
@@ -7063,12 +7204,12 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
       ...((responseFormat == null ? void 0 : responseFormat.type) === "json" || (openaiOptions == null ? void 0 : openaiOptions.textVerbosity)) && {
         text: {
           ...(responseFormat == null ? void 0 : responseFormat.type) === "json" && {
-            format: responseFormat.schema != null ? {
+            format: normalizedResponseFormatSchema != null ? {
               type: "json_schema",
               strict: strictJsonSchema,
               name: (_i = responseFormat.name) != null ? _i : "response",
               description: responseFormat.description,
-              schema: responseFormat.schema
+              schema: normalizedResponseFormatSchema.schema
             } : { type: "json_object" }
           },
           ...(openaiOptions == null ? void 0 : openaiOptions.textVerbosity) && {
@@ -9097,6 +9238,17 @@ var openaiBatchProviderOptionsSchema = lazySchema26(
     })
   )
 );
+function assertTextBatchRequests(requests) {
+  for (const request of requests) {
+    const requestType = request.type;
+    if (requestType !== "text") {
+      throw new UnsupportedFunctionalityError7({
+        functionality: `batch request type: ${requestType}`,
+        message: `The OpenAI Batch API does not support batch requests with type "${requestType}".`
+      });
+    }
+  }
+}
 var openaiBatchResponseZodSchema = () => z28.object({
   id: z28.string(),
   status: z28.string(),
@@ -9155,6 +9307,7 @@ var OpenAIBatch = class {
   }
   async doStartBatch(options) {
     var _a2, _b, _c, _d, _e, _f;
+    assertTextBatchRequests(options.requests);
     validateSingleModel(options.requests);
     const fileParts = [];
     const warnings = options.webhookUrl == null ? [] : [
@@ -9745,9 +9898,486 @@ async function convertOpenAIBatchResult(body) {
   };
 }
 
+// src/realtime/openai-realtime-factory.ts
+import {
+  InvalidArgumentError as InvalidArgumentError4,
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError10
+} from "@ai-sdk/provider";
+
+// src/live/openai-realtime-model-live.ts
+import {
+  createJsonResponseHandler as createJsonResponseHandler8,
+  postJsonToApi as postJsonToApi7
+} from "@ai-sdk/provider-utils";
+import { z as z32 } from "zod/v4";
+
+// src/live/openai-live-event-mapper.ts
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError9
+} from "@ai-sdk/provider";
+import { z as z31 } from "zod/v4";
+
+// src/live/openai-live-session-config.ts
+import {
+  InvalidArgumentError as InvalidArgumentError3,
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError8
+} from "@ai-sdk/provider";
+import { z as z30 } from "zod/v4";
+
+// src/live/openai-realtime-model-live-options.ts
+import { z as z29 } from "zod/v4";
+var serverEventSelectorSchema = z29.strictObject({
+  type: z29.string(),
+  responseEvent: z29.string().optional()
+}).refine(
+  (selector) => selector.type === "response.event" === (selector.responseEvent !== void 0),
+  "responseEvent is required for response.event and forbidden for other event types."
+);
+var openaiRealtimeModelLiveOptionsSchema = z29.strictObject({
+  client: z29.strictObject({
+    dataChannel: z29.strictObject({
+      allowedClientEvents: z29.union([z29.literal("all"), z29.array(z29.string())]).optional(),
+      allowedServerEvents: z29.union([z29.literal("all"), z29.array(serverEventSelectorSchema)]).optional()
+    })
+  }).optional(),
+  delegation: z29.strictObject({ type: z29.literal("client") }).nullable().optional(),
+  input: z29.array(
+    z29.discriminatedUnion("role", [
+      z29.strictObject({
+        type: z29.literal("message"),
+        role: z29.enum(["developer", "user"]),
+        content: z29.tuple([
+          z29.strictObject({ type: z29.literal("input_text"), text: z29.string() })
+        ])
+      }),
+      z29.strictObject({
+        type: z29.literal("message"),
+        role: z29.literal("assistant"),
+        content: z29.tuple([
+          z29.strictObject({
+            type: z29.enum(["text", "output_text"]),
+            text: z29.string()
+          })
+        ])
+      })
+    ])
+  ).max(128).optional(),
+  store: z29.boolean().optional(),
+  voice: z29.strictObject({ id: z29.string().min(1) }).optional()
+});
+
+// src/live/openai-live-session-config.ts
+var audioFormatSchema = z30.union([
+  z30.strictObject({
+    type: z30.literal("audio/pcm"),
+    rate: z30.union([z30.literal(16e3), z30.literal(24e3)])
+  }),
+  z30.strictObject({
+    type: z30.enum(["audio/pcma", "audio/pcmu"]),
+    rate: z30.literal(8e3)
+  })
+]);
+function buildOpenAILiveSessionConfig(config, modelId, transport = "websocket") {
+  var _a2, _b, _c, _d, _e, _f;
+  for (const key of Object.keys(config)) {
+    if (![
+      "instructions",
+      "voice",
+      "inputAudioFormat",
+      "outputAudioFormat",
+      "providerOptions"
+    ].includes(key)) {
+      throw new UnsupportedFunctionalityError8({
+        functionality: `OpenAI Live session setting: ${key}`
+      });
+    }
+  }
+  if (z30.object({ delegation: z30.object({ type: z30.literal("responses") }) }).safeParse((_a2 = config.providerOptions) == null ? void 0 : _a2.openai).success) {
+    throw new UnsupportedFunctionalityError8({
+      functionality: "OpenAI Live Responses delegation; only client delegation is supported"
+    });
+  }
+  const options = openaiRealtimeModelLiveOptionsSchema.parse(
+    (_c = (_b = config.providerOptions) == null ? void 0 : _b.openai) != null ? _c : {}
+  );
+  if (options.client !== void 0 && transport !== "webrtc") {
+    throw new UnsupportedFunctionalityError8({
+      functionality: "OpenAI Live client permissions outside WebRTC startup"
+    });
+  }
+  if (options.voice != null && config.voice != null) {
+    throw new InvalidArgumentError3({
+      argument: "voice",
+      message: "Choose either voice or providerOptions.openai.voice."
+    });
+  }
+  if (transport === "webrtc" && (config.inputAudioFormat !== void 0 || config.outputAudioFormat !== void 0)) {
+    throw new UnsupportedFunctionalityError8({
+      functionality: "Fixed audio formats for OpenAI Live WebRTC; audio is negotiated through SDP"
+    });
+  }
+  const inputFormat = config.inputAudioFormat == null ? void 0 : audioFormatSchema.parse(config.inputAudioFormat);
+  const outputFormat = config.outputAudioFormat == null ? void 0 : audioFormatSchema.parse(config.outputAudioFormat);
+  if (inputFormat != null && outputFormat != null && (inputFormat.type !== outputFormat.type || inputFormat.rate !== outputFormat.rate)) {
+    throw new InvalidArgumentError3({
+      argument: "outputAudioFormat",
+      message: "OpenAI Live requires the same input and output audio format."
+    });
+  }
+  return {
+    model: modelId,
+    ...config.instructions !== void 0 ? { instructions: config.instructions } : {},
+    audio: {
+      ...transport === "websocket" ? {
+        format: (_d = inputFormat != null ? inputFormat : outputFormat) != null ? _d : { type: "audio/pcm", rate: 24e3 }
+      } : {},
+      output: { voice: (_f = (_e = options.voice) != null ? _e : config.voice) != null ? _f : "marin" }
+    },
+    ...options.delegation !== void 0 ? { delegation: options.delegation } : {},
+    ...options.client !== void 0 ? {
+      client: {
+        data_channel: {
+          ...options.client.dataChannel.allowedClientEvents !== void 0 ? {
+            allowed_client_events: options.client.dataChannel.allowedClientEvents
+          } : {},
+          ...options.client.dataChannel.allowedServerEvents !== void 0 ? {
+            allowed_server_events: options.client.dataChannel.allowedServerEvents === "all" ? "all" : options.client.dataChannel.allowedServerEvents.map(
+              (selector) => ({
+                type: selector.type,
+                ...selector.responseEvent !== void 0 ? { response_event: selector.responseEvent } : {}
+              })
+            )
+          } : {}
+        }
+      }
+    } : {},
+    ...options.input !== void 0 ? { input: options.input } : {},
+    ...options.store !== void 0 ? { store: options.store } : {}
+  };
+}
+
+// src/live/openai-live-event-mapper.ts
+var sessionSchema = z31.object({ id: z31.string().min(1) });
+var startedSessionSchema = sessionSchema.extend({
+  delegation: z31.object({ type: z31.enum(["client", "responses"]) }).nullish()
+});
+var usageSchema = z31.object({ seconds: z31.number().nonnegative() });
+var transcriptFields = {
+  delta: z31.string(),
+  start_ms: z31.number().nonnegative(),
+  end_ms: z31.number().nonnegative()
+};
+var acknowledgmentFields = { client_event_id: z31.string().nullish() };
+var appendAcknowledgmentFields = {
+  ...acknowledgmentFields,
+  start_ms: z31.number().nonnegative(),
+  end_ms: z31.number().nonnegative()
+};
+var serverEventSchema = z31.discriminatedUnion("type", [
+  z31.object({
+    type: z31.literal("session.started"),
+    session: startedSessionSchema
+  }),
+  z31.object({
+    type: z31.literal("session.closed"),
+    session: sessionSchema.nullish(),
+    usage: usageSchema,
+    reason: z31.string()
+  }),
+  z31.object({
+    type: z31.literal("session.usage.updated"),
+    usage: usageSchema,
+    context_window: z31.object({ usage_ratio: z31.number().min(0).max(1) }).nullish()
+  }),
+  z31.object({
+    type: z31.literal("session.output_audio.delta"),
+    delta: z31.string()
+  }),
+  z31.object({
+    type: z31.literal("session.input_transcript.delta"),
+    ...transcriptFields
+  }),
+  z31.object({
+    type: z31.literal("session.output_transcript.delta"),
+    ...transcriptFields
+  }),
+  z31.object({
+    type: z31.literal("session.delegation.created"),
+    offset_ms: z31.number().nonnegative().nullish(),
+    delegation: z31.object({
+      id: z31.string().min(1),
+      target: z31.enum(["client", "responses"]).nullish(),
+      response_id: z31.string().min(1).nullish()
+    })
+  }),
+  z31.object({
+    type: z31.literal("session.updated"),
+    session: sessionSchema,
+    ...acknowledgmentFields
+  }),
+  z31.object({
+    type: z31.literal("session.input_audio.muted"),
+    ...acknowledgmentFields
+  }),
+  z31.object({
+    type: z31.literal("session.input_audio.unmuted"),
+    ...acknowledgmentFields
+  }),
+  z31.object({
+    type: z31.literal("session.instructions.appended"),
+    ...appendAcknowledgmentFields
+  }),
+  z31.object({
+    type: z31.literal("session.thinking.appended"),
+    ...appendAcknowledgmentFields
+  }),
+  z31.object({
+    type: z31.literal("session.commentary.appended"),
+    ...appendAcknowledgmentFields
+  }),
+  z31.object({
+    type: z31.literal("error"),
+    error: z31.object({
+      message: z31.string(),
+      code: z31.string().nullish(),
+      client_event_id: z31.string().nullish()
+    })
+  })
+]);
+var knownTypes = new Set(
+  serverEventSchema.options.map((schema) => schema.shape.type.value)
+);
+var envelopeSchema = z31.object({ type: z31.string() });
+function createOpenAILiveServerEventParser() {
+  return (raw) => parseOpenAILiveServerEvent(raw);
+}
+function parseOpenAILiveServerEvent(raw) {
+  return [parseServerEvent(raw)];
+}
+function parseServerEvent(raw) {
+  var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  const envelope = envelopeSchema.safeParse(raw);
+  if (envelope.success && !knownTypes.has(envelope.data.type)) {
+    return { type: "custom", rawType: envelope.data.type, raw };
+  }
+  const parsed = serverEventSchema.safeParse(raw);
+  if (!parsed.success) {
+    return {
+      type: "error",
+      code: "invalid_server_event",
+      message: "Invalid OpenAI Live server event.",
+      raw
+    };
+  }
+  const event = parsed.data;
+  if ("start_ms" in event && event.end_ms < event.start_ms) {
+    return {
+      type: "error",
+      code: "invalid_server_event",
+      message: "Invalid OpenAI Live event time interval.",
+      raw
+    };
+  }
+  switch (event.type) {
+    case "session.started":
+      return {
+        type: "session-started",
+        sessionId: event.session.id,
+        delegationMode: ((_a2 = event.session.delegation) == null ? void 0 : _a2.type) === "responses" ? "provider" : "client",
+        raw
+      };
+    case "session.closed":
+      return {
+        type: "session-closed",
+        sessionId: (_b = event.session) == null ? void 0 : _b.id,
+        usage: event.usage,
+        reason: event.reason,
+        raw
+      };
+    case "session.usage.updated":
+      return {
+        type: "session-usage",
+        usage: event.usage,
+        contextWindowUsageRatio: (_c = event.context_window) == null ? void 0 : _c.usage_ratio,
+        raw
+      };
+    case "session.output_audio.delta":
+      return { type: "audio-chunk", delta: event.delta, raw };
+    case "session.input_transcript.delta":
+    case "session.output_transcript.delta":
+      return {
+        type: "transcript-fragment",
+        speaker: event.type === "session.input_transcript.delta" ? "user" : "assistant",
+        delta: event.delta,
+        startMs: event.start_ms,
+        endMs: event.end_ms,
+        raw
+      };
+    case "session.delegation.created":
+      return {
+        type: "delegation-created",
+        delegationId: event.delegation.id,
+        target: event.delegation.target === "responses" ? "provider" : (_d = event.delegation.target) != null ? _d : void 0,
+        offsetMs: (_e = event.offset_ms) != null ? _e : void 0,
+        ...event.delegation.response_id != null ? { responseId: event.delegation.response_id } : {},
+        raw
+      };
+    case "error":
+      return {
+        type: "error",
+        message: event.error.message,
+        code: (_f = event.error.code) != null ? _f : void 0,
+        clientEventId: (_g = event.error.client_event_id) != null ? _g : void 0,
+        raw
+      };
+    case "session.updated":
+      return {
+        type: "command-acknowledged",
+        command: "session.update",
+        clientEventId: (_h = event.client_event_id) != null ? _h : void 0,
+        raw
+      };
+    case "session.input_audio.muted":
+    case "session.input_audio.unmuted":
+      return {
+        type: "command-acknowledged",
+        command: event.type.slice(0, -1),
+        clientEventId: (_i = event.client_event_id) != null ? _i : void 0,
+        raw
+      };
+    case "session.instructions.appended":
+    case "session.thinking.appended":
+    case "session.commentary.appended":
+      return {
+        type: "command-acknowledged",
+        command: event.type.slice(0, -2),
+        clientEventId: (_j = event.client_event_id) != null ? _j : void 0,
+        raw
+      };
+  }
+}
+function serializeOpenAILiveClientEvent(event, modelId) {
+  var _a2, _b, _c;
+  const eventId = "eventId" in event && event.eventId !== void 0 ? { event_id: event.eventId } : {};
+  switch (event.type) {
+    case "session-start":
+      return {
+        type: "session.start",
+        session: buildOpenAILiveSessionConfig(event.config, modelId),
+        ...eventId
+      };
+    case "session-update":
+      throw new UnsupportedFunctionalityError9({
+        functionality: "OpenAI Live session-update; startup settings are immutable; use context-append or input-audio-mute/input-audio-unmute"
+      });
+    case "session-close":
+      return { type: "session.close", ...eventId };
+    case "input-audio-append":
+      return {
+        type: "session.input_audio.append",
+        audio: event.audio,
+        ...eventId
+      };
+    case "input-audio-mute":
+      return { type: "session.input_audio.mute", ...eventId };
+    case "input-audio-unmute":
+      return { type: "session.input_audio.unmute", ...eventId };
+    case "context-append": {
+      const context = z31.object({
+        content: z31.string(),
+        delegationId: z31.string().min(1).nullable()
+      }).parse(event);
+      const options = z31.strictObject({
+        channel: z31.enum(["instructions", "thinking", "commentary"]).optional()
+      }).parse((_b = (_a2 = event.providerOptions) == null ? void 0 : _a2.openai) != null ? _b : {});
+      return {
+        type: `session.${(_c = options.channel) != null ? _c : "thinking"}.append`,
+        content: context.content,
+        delegation_id: context.delegationId,
+        ...eventId
+      };
+    }
+    default:
+      throw new UnsupportedFunctionalityError9({
+        functionality: `OpenAI Live command: ${event.type}; use continuous audio and context-append instead of voice-turn commands`
+      });
+  }
+}
+
+// src/live/openai-realtime-model-live.ts
+var webRTCSessionSchema = z32.object({
+  session: z32.object({ id: z32.string().min(1) }),
+  transport: z32.object({ type: z32.literal("webrtc"), sdp: z32.string().min(1) })
+});
+var OpenAIRealtimeModelLive = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v4";
+    this.capabilities = {
+      conversation: "continuous",
+      transports: ["websocket", "webrtc"],
+      connections: ["server-websocket", "webrtc"],
+      startup: "session-start",
+      finalization: "session-close"
+    };
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  getWebRTCConfig() {
+    return { dataChannelLabel: "oai-events" };
+  }
+  getServerWebSocketConfig() {
+    const url = new URL(`${this.config.baseURL}/live/sessions`);
+    url.protocol = url.protocol === "http:" ? "ws:" : "wss:";
+    const headers = {};
+    for (const [key, value] of Object.entries(this.config.headers())) {
+      if (value !== void 0) headers[key] = value;
+    }
+    return { url: url.toString(), headers };
+  }
+  async doCreateWebRTCSession({
+    sdp,
+    sessionConfig = {},
+    abortSignal
+  }) {
+    const session = buildOpenAILiveSessionConfig(
+      sessionConfig,
+      this.modelId,
+      "webrtc"
+    );
+    const { value } = await postJsonToApi7({
+      url: `${this.config.baseURL}/live/sessions`,
+      headers: this.config.headers(),
+      body: {
+        session,
+        transport: { type: "webrtc", sdp: z32.string().min(1).parse(sdp) }
+      },
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler8(webRTCSessionSchema),
+      abortSignal,
+      fetch: this.config.fetch
+    });
+    return { sessionId: value.session.id, sdp: value.transport.sdp };
+  }
+  parseServerEvent(raw) {
+    return parseOpenAILiveServerEvent(raw);
+  }
+  createServerEventParser() {
+    return createOpenAILiveServerEventParser();
+  }
+  serializeClientEvent(event) {
+    return serializeOpenAILiveClientEvent(event, this.modelId);
+  }
+  buildSessionConfig(config) {
+    return buildOpenAILiveSessionConfig(config, this.modelId);
+  }
+};
+
 // src/realtime/openai-realtime-event-mapper.ts
 function parseOpenAIRealtimeServerEvent(raw) {
-  var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
+  var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u;
   const event = raw;
   const type = event.type;
   switch (type) {
@@ -9914,6 +10544,7 @@ function parseOpenAIRealtimeServerEvent(raw) {
         type: "error",
         message: (_q = (_p = (_o = event.error) == null ? void 0 : _o.message) != null ? _p : event.message) != null ? _q : "Unknown error",
         code: (_s = (_r = event.error) == null ? void 0 : _r.code) != null ? _s : event.code,
+        clientEventId: (_u = (_t = event.error) == null ? void 0 : _t.event_id) != null ? _u : void 0,
         raw
       };
     // ── Pass-through ────────────────────────────────────────────────
@@ -9926,12 +10557,14 @@ function serializeOpenAIRealtimeClientEvent(event, modelId) {
     case "session-update":
       return {
         type: "session.update",
-        session: buildOpenAISessionConfig(event.config, modelId)
+        session: buildOpenAISessionConfig(event.config, modelId),
+        ...event.eventId != null ? { event_id: event.eventId } : {}
       };
     case "input-audio-append":
       return {
         type: "input_audio_buffer.append",
-        audio: event.audio
+        audio: event.audio,
+        ...event.eventId != null ? { event_id: event.eventId } : {}
       };
     case "input-audio-commit":
       return { type: "input_audio_buffer.commit" };
@@ -10134,12 +10767,53 @@ var OpenAIRealtimeModel = class {
   }
 };
 
+// src/realtime/openai-realtime-factory.ts
+var knownLiveModelIds = ["gpt-live-1"];
+function resolveRealtimeApi(modelId, { api } = {}) {
+  if (api !== void 0) {
+    if (api !== "live" && api !== "realtime") {
+      throw new InvalidArgumentError4({
+        argument: "api",
+        message: 'OpenAI realtime api must be "live" or "realtime".'
+      });
+    }
+    return api;
+  }
+  return knownLiveModelIds.some((knownModelId) => knownModelId === modelId) ? "live" : "realtime";
+}
+function createOpenAIRealtimeFactory(config) {
+  const createModel = (modelId, options) => {
+    const api = resolveRealtimeApi(modelId, options);
+    const modelConfig = { ...config, provider: `${config.provider}.${api}` };
+    return api === "live" ? new OpenAIRealtimeModelLive(modelId, modelConfig) : new OpenAIRealtimeModel(modelId, modelConfig);
+  };
+  return Object.assign(createModel, {
+    getToken: async (options) => {
+      const model = createModel(options.model, options);
+      if (model instanceof OpenAIRealtimeModelLive) {
+        throw new UnsupportedFunctionalityError10({
+          functionality: "Short-lived OpenAI credentials for the Live API. Use server WebSocket setup via getServerWebSocketConfig() with a server-side API key instead."
+        });
+      }
+      const secret = await model.doCreateClientSecret({
+        sessionConfig: options.sessionConfig,
+        expiresAfterSeconds: options.expiresAfterSeconds
+      });
+      return {
+        token: secret.token,
+        url: secret.url,
+        expiresAt: secret.expiresAt
+      };
+    }
+  });
+}
+
 // src/speech/openai-speech-model.ts
 import {
   combineHeaders as combineHeaders8,
   createBinaryResponseHandler,
   parseProviderOptions as parseProviderOptions9,
-  postJsonToApi as postJsonToApi7,
+  postJsonToApi as postJsonToApi8,
   serializeModelOptions as serializeModelOptions6,
   WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE6,
   WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE6
@@ -10150,12 +10824,12 @@ import {
   lazySchema as lazySchema27,
   zodSchema as zodSchema27
 } from "@ai-sdk/provider-utils";
-import { z as z29 } from "zod/v4";
+import { z as z33 } from "zod/v4";
 var openaiSpeechModelOptionsSchema = lazySchema27(
   () => zodSchema27(
-    z29.object({
-      instructions: z29.string().nullish(),
-      speed: z29.number().min(0.25).max(4).default(1).nullish()
+    z33.object({
+      instructions: z33.string().nullish(),
+      speed: z33.number().min(0.25).max(4).default(1).nullish()
     })
   )
 );
@@ -10242,7 +10916,7 @@ var OpenAISpeechModel = class _OpenAISpeechModel {
       value: audio,
       responseHeaders,
       rawValue: rawResponse
-    } = await postJsonToApi7({
+    } = await postJsonToApi8({
       url: this.config.url({
         path: "/audio/speech",
         modelId: this.modelId
@@ -10272,13 +10946,13 @@ var OpenAISpeechModel = class _OpenAISpeechModel {
 
 // src/transcription/openai-transcription-model.ts
 import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError6
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError11
 } from "@ai-sdk/provider";
 import {
   combineHeaders as combineHeaders9,
   convertBase64ToUint8Array as convertBase64ToUint8Array2,
   convertToBase64 as convertToBase643,
-  createJsonResponseHandler as createJsonResponseHandler8,
+  createJsonResponseHandler as createJsonResponseHandler9,
   connectToWebSocket,
   mediaTypeToExtension,
   parseProviderOptions as parseProviderOptions10,
@@ -10293,41 +10967,41 @@ import {
 
 // src/transcription/openai-transcription-api.ts
 import { lazySchema as lazySchema28, zodSchema as zodSchema28 } from "@ai-sdk/provider-utils";
-import { z as z30 } from "zod/v4";
+import { z as z34 } from "zod/v4";
 var openaiTranscriptionResponseSchema = lazySchema28(
   () => zodSchema28(
-    z30.object({
-      text: z30.string(),
-      language: z30.string().nullish(),
-      duration: z30.number().nullish(),
-      words: z30.array(
-        z30.object({
-          word: z30.string(),
-          start: z30.number(),
-          end: z30.number()
+    z34.object({
+      text: z34.string(),
+      language: z34.string().nullish(),
+      duration: z34.number().nullish(),
+      words: z34.array(
+        z34.object({
+          word: z34.string(),
+          start: z34.number(),
+          end: z34.number()
         })
       ).nullish(),
-      segments: z30.array(
-        z30.union([
-          z30.object({
-            id: z30.number(),
-            seek: z30.number(),
-            start: z30.number(),
-            end: z30.number(),
-            text: z30.string(),
-            tokens: z30.array(z30.number()),
-            temperature: z30.number(),
-            avg_logprob: z30.number(),
-            compression_ratio: z30.number(),
-            no_speech_prob: z30.number()
+      segments: z34.array(
+        z34.union([
+          z34.object({
+            id: z34.number(),
+            seek: z34.number(),
+            start: z34.number(),
+            end: z34.number(),
+            text: z34.string(),
+            tokens: z34.array(z34.number()),
+            temperature: z34.number(),
+            avg_logprob: z34.number(),
+            compression_ratio: z34.number(),
+            no_speech_prob: z34.number()
           }),
-          z30.object({
-            type: z30.literal("transcript.text.segment"),
-            id: z30.string(),
-            start: z30.number(),
-            end: z30.number(),
-            text: z30.string(),
-            speaker: z30.string()
+          z34.object({
+            type: z34.literal("transcript.text.segment"),
+            id: z34.string(),
+            start: z34.number(),
+            end: z34.number(),
+            text: z34.string(),
+            speaker: z34.string()
           })
         ])
       ).nullish()
@@ -10340,60 +11014,60 @@ import {
   lazySchema as lazySchema29,
   zodSchema as zodSchema29
 } from "@ai-sdk/provider-utils";
-import { z as z31 } from "zod/v4";
+import { z as z35 } from "zod/v4";
 var openAITranscriptionModelOptions = lazySchema29(
   () => zodSchema29(
-    z31.object({
+    z35.object({
       /**
        * Additional information to include in the transcription response.
        */
-      include: z31.array(z31.string()).optional(),
+      include: z35.array(z35.string()).optional(),
       /**
        * The language of the input audio in ISO-639-1 format.
        */
-      language: z31.string().optional(),
+      language: z35.string().optional(),
       /**
        * An optional text to guide the model's style or continue a previous audio segment.
        */
-      prompt: z31.string().optional(),
+      prompt: z35.string().optional(),
       /**
        * The sampling temperature, between 0 and 1.
        * @default 0
        */
-      temperature: z31.number().min(0).max(1).default(0).optional(),
+      temperature: z35.number().min(0).max(1).default(0).optional(),
       /**
        * The timestamp granularities to populate for this transcription.
        * @default ['segment']
        */
-      timestampGranularities: z31.array(z31.enum(["word", "segment"])).default(["segment"]).optional(),
+      timestampGranularities: z35.array(z35.enum(["word", "segment"])).default(["segment"]).optional(),
       /**
        * The format of the transcription response.
        */
-      responseFormat: z31.enum(["json", "verbose_json", "diarized_json"]).optional(),
+      responseFormat: z35.enum(["json", "verbose_json", "diarized_json"]).optional(),
       /**
        * Controls how the audio is split into chunks before transcription.
        */
-      chunkingStrategy: z31.union([
-        z31.literal("auto"),
-        z31.object({
-          type: z31.literal("server_vad"),
-          threshold: z31.number().min(0).max(1).optional(),
-          prefixPaddingMs: z31.number().int().min(0).optional(),
-          silenceDurationMs: z31.number().int().min(0).optional()
+      chunkingStrategy: z35.union([
+        z35.literal("auto"),
+        z35.object({
+          type: z35.literal("server_vad"),
+          threshold: z35.number().min(0).max(1).optional(),
+          prefixPaddingMs: z35.number().int().min(0).optional(),
+          silenceDurationMs: z35.number().int().min(0).optional()
         })
       ]).optional(),
       /**
        * Options for streaming transcription models such as `gpt-realtime-whisper`.
        */
-      streaming: z31.object({
+      streaming: z35.object({
         /**
          * Latency/accuracy tradeoff for realtime transcription.
          */
-        delay: z31.enum(["minimal", "low", "medium", "high", "xhigh"]).optional(),
+        delay: z35.enum(["minimal", "low", "medium", "high", "xhigh"]).optional(),
         /**
          * Additional fields to include in realtime transcription events.
          */
-        include: z31.array(z31.string()).optional()
+        include: z35.array(z35.string()).optional()
       }).optional()
     })
   )
@@ -10562,7 +11236,7 @@ var OpenAITranscriptionModel = class _OpenAITranscriptionModel {
   async doGenerate(options) {
     var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
     if (isRealtimeTranscriptionModelId(this.modelId)) {
-      throw new UnsupportedFunctionalityError6({
+      throw new UnsupportedFunctionalityError11({
         functionality: `non-streaming transcription with ${this.modelId}`
       });
     }
@@ -10580,7 +11254,7 @@ var OpenAITranscriptionModel = class _OpenAITranscriptionModel {
       headers: combineHeaders9((_e = (_d = this.config).headers) == null ? void 0 : _e.call(_d), options.headers),
       formData,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler8(
+      successfulResponseHandler: createJsonResponseHandler9(
         openaiTranscriptionResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -10629,7 +11303,7 @@ var OpenAITranscriptionModel = class _OpenAITranscriptionModel {
   async doStream(options) {
     var _a2, _b, _c, _d, _e, _f, _g;
     if (!isRealtimeTranscriptionModelId(this.modelId)) {
-      throw new UnsupportedFunctionalityError6({
+      throw new UnsupportedFunctionalityError11({
         functionality: `streaming transcription with ${this.modelId}`
       });
     }
@@ -10870,7 +11544,7 @@ function getOpenAIRealtimeConnection(headers) {
 
 // src/speech-translation/openai-speech-translation-model.ts
 import {
-  InvalidArgumentError as InvalidArgumentError3
+  InvalidArgumentError as InvalidArgumentError5
 } from "@ai-sdk/provider";
 import {
   combineHeaders as combineHeaders10,
@@ -10890,9 +11564,9 @@ import {
   lazySchema as lazySchema30,
   zodSchema as zodSchema30
 } from "@ai-sdk/provider-utils";
-import { z as z32 } from "zod/v4";
+import { z as z36 } from "zod/v4";
 var openAISpeechTranslationModelOptions = lazySchema30(
-  () => zodSchema30(z32.object({}))
+  () => zodSchema30(z36.object({}))
 );
 
 // src/speech-translation/openai-speech-translation-model.ts
@@ -10917,7 +11591,7 @@ var OpenAISpeechTranslationModel = class _OpenAISpeechTranslationModel {
   async doStream(options) {
     var _a2, _b, _c, _d, _e;
     if (options.targetLanguage == null) {
-      throw new InvalidArgumentError3({
+      throw new InvalidArgumentError5({
         argument: "targetLanguage",
         message: `targetLanguage is required for translation model '${this.modelId}'.`
       });
@@ -11157,7 +11831,7 @@ function buildOpenAIRealtimeSpeechTranslationSession({
 }
 function validateOpenAISpeechTranslationInputAudioFormat(inputAudioFormat) {
   if (inputAudioFormat.type !== "audio/pcm" || inputAudioFormat.rate != null && inputAudioFormat.rate !== 24e3) {
-    throw new InvalidArgumentError3({
+    throw new InvalidArgumentError5({
       argument: "inputAudioFormat",
       message: "The OpenAI Realtime translation API only supports 24kHz 16-bit PCM input audio."
     });
@@ -11189,33 +11863,33 @@ function getOpenAIRealtimeConnection2(headers) {
 import {
   combineHeaders as combineHeaders11,
   convertInlineFileDataToUint8Array as convertInlineFileDataToUint8Array2,
-  createJsonResponseHandler as createJsonResponseHandler9,
+  createJsonResponseHandler as createJsonResponseHandler10,
   postFormDataToApi as postFormDataToApi4
 } from "@ai-sdk/provider-utils";
 
 // src/skills/openai-skills-api.ts
 import { lazySchema as lazySchema31, zodSchema as zodSchema31 } from "@ai-sdk/provider-utils";
-import { z as z33 } from "zod/v4";
+import { z as z37 } from "zod/v4";
 var openaiSkillResponseSchema = lazySchema31(
   () => zodSchema31(
-    z33.object({
-      id: z33.string(),
-      name: z33.string().nullish(),
-      description: z33.string().nullish(),
-      default_version: z33.string().nullish(),
-      latest_version: z33.string().nullish(),
-      created_at: z33.number(),
-      updated_at: z33.number().nullish()
+    z37.object({
+      id: z37.string(),
+      name: z37.string().nullish(),
+      description: z37.string().nullish(),
+      default_version: z37.string().nullish(),
+      latest_version: z37.string().nullish(),
+      created_at: z37.number(),
+      updated_at: z37.number().nullish()
     })
   )
 );
 var openaiSkillVersionResponseSchema = lazySchema31(
   () => zodSchema31(
-    z33.object({
-      id: z33.string(),
-      version: z33.string().nullish(),
-      name: z33.string().nullish(),
-      description: z33.string().nullish()
+    z37.object({
+      id: z37.string(),
+      version: z37.string().nullish(),
+      name: z37.string().nullish(),
+      description: z37.string().nullish()
     })
   )
 );
@@ -11247,7 +11921,7 @@ var OpenAISkills = class {
       headers: combineHeaders11(this.config.headers()),
       formData,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler9(
+      successfulResponseHandler: createJsonResponseHandler10(
         openaiSkillResponseSchema
       ),
       fetch: this.config.fetch
@@ -11270,7 +11944,7 @@ var OpenAISkills = class {
 };
 
 // src/version.ts
-var VERSION = true ? "4.0.65" : "0.0.0-test";
+var VERSION = true ? "4.0.67" : "0.0.0-test";
 
 // src/openai-provider.ts
 function createOpenAI(options = {}) {
@@ -11384,29 +12058,6 @@ function createOpenAI(options = {}) {
       fileIdPrefixes: ["file-"]
     }
   });
-  const createRealtimeModel = (modelId) => new OpenAIRealtimeModel(modelId, {
-    provider: `${providerName}.realtime`,
-    baseURL,
-    headers: getHeaders,
-    fetch: options.fetch
-  });
-  const experimentalRealtimeFactory = Object.assign(
-    (modelId) => createRealtimeModel(modelId),
-    {
-      getToken: async (tokenOptions) => {
-        const model = createRealtimeModel(tokenOptions.model);
-        const secret = await model.doCreateClientSecret({
-          sessionConfig: tokenOptions.sessionConfig,
-          expiresAfterSeconds: tokenOptions.expiresAfterSeconds
-        });
-        return {
-          token: secret.token,
-          url: secret.url,
-          expiresAt: secret.expiresAt
-        };
-      }
-    }
-  );
   const provider = function(modelId) {
     return createLanguageModel(modelId);
   };
@@ -11430,13 +12081,19 @@ function createOpenAI(options = {}) {
   provider.files = createFiles;
   provider.skills = createSkills;
   provider.experimental_batch = createBatch;
-  provider.experimental_realtime = experimentalRealtimeFactory;
+  provider.experimental_realtime = createOpenAIRealtimeFactory({
+    provider: providerName,
+    baseURL,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
   provider.tools = openaiTools;
   return provider;
 }
 var openai = createOpenAI();
 export {
   OpenAIRealtimeModel as Experimental_OpenAIRealtimeModel,
+  OpenAIRealtimeModelLive as Experimental_OpenAIRealtimeModelLive,
   OpenAISpeechTranslationModel as Experimental_OpenAISpeechTranslationModel,
   OpenAISpeechTranslationModel as Experimental_OpenAITranslationModel,
   VERSION,