@ai-sdk/openai 4.0.66 → 4.0.67

package/dist/index.js

@@ -9898,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) {
@@ -10067,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 ────────────────────────────────────────────────
@@ -10079,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" };
@@ -10287,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
@@ -10303,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()
     })
   )
 );
@@ -10395,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
@@ -10425,13 +10946,13 @@ var OpenAISpeechModel = class _OpenAISpeechModel {
 
 // src/transcription/openai-transcription-model.ts
 import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError8
+  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,
@@ -10446,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()
@@ -10493,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()
     })
   )
@@ -10715,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 UnsupportedFunctionalityError8({
+      throw new UnsupportedFunctionalityError11({
         functionality: `non-streaming transcription with ${this.modelId}`
       });
     }
@@ -10733,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,
@@ -10782,7 +11303,7 @@ var OpenAITranscriptionModel = class _OpenAITranscriptionModel {
   async doStream(options) {
     var _a2, _b, _c, _d, _e, _f, _g;
     if (!isRealtimeTranscriptionModelId(this.modelId)) {
-      throw new UnsupportedFunctionalityError8({
+      throw new UnsupportedFunctionalityError11({
         functionality: `streaming transcription with ${this.modelId}`
       });
     }
@@ -11023,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,
@@ -11043,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
@@ -11070,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}'.`
       });
@@ -11310,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."
     });
@@ -11342,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()
     })
   )
 );
@@ -11400,7 +11921,7 @@ var OpenAISkills = class {
       headers: combineHeaders11(this.config.headers()),
       formData,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler9(
+      successfulResponseHandler: createJsonResponseHandler10(
         openaiSkillResponseSchema
       ),
       fetch: this.config.fetch
@@ -11423,7 +11944,7 @@ var OpenAISkills = class {
 };
 
 // src/version.ts
-var VERSION = true ? "4.0.66" : "0.0.0-test";
+var VERSION = true ? "4.0.67" : "0.0.0-test";
 
 // src/openai-provider.ts
 function createOpenAI(options = {}) {
@@ -11537,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);
   };
@@ -11583,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,