ai 7.0.100 → 7.0.102

package/dist/index.js

@@ -14,7 +14,7 @@ import {
   createIdGenerator as createIdGenerator9,
   dynamicTool,
   experimental_toolCaller,
-  generateId as generateId3,
+  generateId as generateId4,
   jsonSchema,
   parseJsonEventStream as parseJsonEventStream3,
   tool,
@@ -1178,7 +1178,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "7.0.100" : "0.0.0-test";
+var VERSION = true ? "7.0.102" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -2007,6 +2007,9 @@ function getMediaTypeFromUrl(url, fallbackMediaType = "application/octet-stream"
 
 // src/prompt/create-tool-model-output.ts
 import { getErrorMessage as getErrorMessage3 } from "@ai-sdk/provider";
+import {
+  parseJSON
+} from "@ai-sdk/provider-utils";
 async function createToolModelOutput({
   toolCallId,
   input,
@@ -2017,15 +2020,19 @@ async function createToolModelOutput({
   if (errorMode === "text") {
     return { type: "error-text", value: getErrorMessage3(output) };
   } else if (errorMode === "json") {
-    return { type: "error-json", value: toJSONValue(output) };
+    return { type: "error-json", value: await toJSONValue(output) };
   }
   if (tool2 == null ? void 0 : tool2.toModelOutput) {
     return await tool2.toModelOutput({ toolCallId, input, output });
   }
-  return typeof output === "string" ? { type: "text", value: output } : { type: "json", value: toJSONValue(output) };
+  return typeof output === "string" ? { type: "text", value: output } : { type: "json", value: await toJSONValue(output) };
 }
-function toJSONValue(value) {
-  return value === void 0 ? null : value;
+async function toJSONValue(value) {
+  if (value === void 0) {
+    return null;
+  }
+  const serialized = JSON.stringify(value);
+  return serialized === void 0 ? null : await parseJSON({ text: serialized });
 }
 
 // src/prompt/prepare-language-model-call-options.ts
@@ -5549,7 +5556,7 @@ async function generateText({
   experimental_include,
   include = experimental_include,
   _internal: {
-    generateId: generateId4 = originalGenerateId,
+    generateId: generateId5 = originalGenerateId,
     generateCallId = originalGenerateCallId,
     now: now2 = now
   } = {},
@@ -5949,7 +5956,7 @@ async function generateText({
                   }
                 );
                 const responseData = {
-                  id: (_b27 = (_a28 = result.response) == null ? void 0 : _a28.id) != null ? _b27 : generateId4(),
+                  id: (_b27 = (_a28 = result.response) == null ? void 0 : _a28.id) != null ? _b27 : generateId5(),
                   timestamp: (_d3 = (_c3 = result.response) == null ? void 0 : _c3.timestamp) != null ? _d3 : /* @__PURE__ */ new Date(),
                   modelId: (_f2 = (_e2 = result.response) == null ? void 0 : _e2.modelId) != null ? _f2 : stepModel.modelId,
                   headers: (_g2 = result.response) == null ? void 0 : _g2.headers,
@@ -6069,7 +6076,7 @@ async function generateText({
                 if (toolApprovalStatus.type === "not-applicable") {
                   continue;
                 }
-                const approvalId = generateId4();
+                const approvalId = generateId5();
                 const signature = await maybeSignApproval({
                   secret: experimental_toolApprovalSecret,
                   approvalId,
@@ -8393,7 +8400,7 @@ function executeToolsFromStream({
   toolApproval,
   runtimeContext,
   toolApprovalSecret,
-  generateId: generateId4,
+  generateId: generateId5,
   onToolExecutionStart,
   onToolExecutionEnd,
   executeToolInTelemetryContext,
@@ -8432,7 +8439,7 @@ function executeToolsFromStream({
               }
               return;
             }
-            const approvalId = generateId4();
+            const approvalId = generateId5();
             const signature = await maybeSignApproval({
               secret: toolApprovalSecret,
               approvalId,
@@ -8467,6 +8474,11 @@ function executeToolsFromStream({
                   reason: toolApprovalStatus.reason,
                   providerExecuted: chunk.providerExecuted
                 });
+                controller.enqueue({
+                  type: "tool-output-denied",
+                  toolCallId: chunk.toolCallId,
+                  toolName: chunk.toolName
+                });
                 return;
               }
               case "approved": {
@@ -8715,7 +8727,7 @@ async function streamLanguageModelCall({
   toolsContext,
   experimental_sandbox: sandbox,
   _internal: {
-    generateId: generateId4 = originalGenerateId2,
+    generateId: generateId5 = originalGenerateId2,
     generateCallId = originalGenerateCallId2,
     now: now2 = now
   } = {},
@@ -8801,7 +8813,7 @@ async function streamLanguageModelCall({
       provider: resolvedModel.provider,
       modelId: resolvedModel.modelId,
       toolChoice: stepToolChoice,
-      generateId: generateId4,
+      generateId: generateId5,
       now: now2,
       callStartTimestampMs,
       onLanguageModelCallEnd
@@ -8823,7 +8835,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
   provider,
   modelId,
   toolChoice,
-  generateId: generateId4,
+  generateId: generateId5,
   now: now2,
   callStartTimestampMs,
   onLanguageModelCallEnd
@@ -8835,7 +8847,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
   const reasoningPartIndexes = /* @__PURE__ */ new Map();
   const rawTextPartIndexes = /* @__PURE__ */ new Map();
   const rawReasoningPartIndexes = /* @__PURE__ */ new Map();
-  let responseId = generateId4();
+  let responseId = generateId5();
   let responseModelId = modelId;
   let timeToFirstOutputMs;
   let previousOutputChunkTimestampMs;
@@ -9242,6 +9254,7 @@ var isOutputChunkType = {
   "tool-call": true,
   "tool-result": false,
   "tool-error": false,
+  "tool-output-denied": false,
   "tool-execution-end": false,
   "model-call-start": false,
   "model-call-response-metadata": false,
@@ -9324,7 +9337,7 @@ function streamText({
   include = experimental_include,
   _internal: {
     now: now2 = now,
-    generateId: generateId4 = originalGenerateId3,
+    generateId: generateId5 = originalGenerateId3,
     generateCallId = originalGenerateCallId3
   } = {},
   ...settings
@@ -9403,7 +9416,7 @@ function streamText({
     onToolExecutionStart: resolvedOnToolExecutionStart,
     onToolExecutionEnd: resolvedOnToolExecutionEnd,
     now: now2,
-    generateId: generateId4,
+    generateId: generateId5,
     generateCallId,
     download: download2,
     // assign default values to include:
@@ -9631,7 +9644,7 @@ var DefaultStreamTextResult = class {
     providerOptions,
     prepareStep,
     now: now2,
-    generateId: generateId4,
+    generateId: generateId5,
     generateCallId,
     timeout,
     onChunk,
@@ -9686,7 +9699,7 @@ var DefaultStreamTextResult = class {
           usedIds.add(id);
           return id;
         }
-        const generatedId = generateId4();
+        const generatedId = generateId5();
         let uniqueId = generatedId;
         let suffix = 0;
         while (usedIds.has(uniqueId)) {
@@ -10621,7 +10634,7 @@ var DefaultStreamTextResult = class {
             toolApproval,
             runtimeContext,
             toolApprovalSecret: experimental_toolApprovalSecret,
-            generateId: generateId4,
+            generateId: generateId5,
             // the callbacks need to be passed down and handled by executeToolCall
             // to guarantee that the onToolExecutionStart callback is invoked before the tool execute function
             onToolExecutionStart: filterNullable2(
@@ -10664,7 +10677,7 @@ var DefaultStreamTextResult = class {
           let modelCallPerformance = createModelCallPerformance();
           const toolExecutionMs = {};
           const createStepResponse = () => ({
-            id: generateId4(),
+            id: generateId5(),
             timestamp: /* @__PURE__ */ new Date(),
             modelId: model.modelId
           });
@@ -10730,7 +10743,8 @@ var DefaultStreamTextResult = class {
                     case "tool-input-start":
                     case "tool-input-end":
                     case "tool-input-delta":
-                    case "tool-approval-request": {
+                    case "tool-approval-request":
+                    case "tool-output-denied": {
                       enqueueStepPart(controller, chunk);
                       break;
                     }
@@ -11494,7 +11508,7 @@ function createUIMessageStream({
   onStepFinish,
   onEnd,
   onFinish,
-  generateId: generateId4 = generateIdFunc
+  generateId: generateId5 = generateIdFunc
 }) {
   let controller;
   const ongoingStreamPromises = [];
@@ -11586,7 +11600,7 @@ function createUIMessageStream({
   });
   return handleUIMessageStreamFinish({
     stream,
-    messageId: generateId4(),
+    messageId: generateId5(),
     originalMessages,
     onStepEnd: onStepEnd != null ? onStepEnd : onStepFinish,
     onEnd: onEnd != null ? onEnd : onFinish,
@@ -14481,7 +14495,7 @@ async function generateObject(options) {
     onStepFinish,
     onFinish,
     _internal: {
-      generateId: generateId4 = originalGenerateId4,
+      generateId: generateId5 = originalGenerateId4,
       currentDate = () => /* @__PURE__ */ new Date()
     } = {},
     ...settings
@@ -14521,7 +14535,7 @@ async function generateObject(options) {
   const resolvedOnStepStart = onStepStart != null ? onStepStart : experimental_onStepStart;
   const resolvedOnStepEnd = onStepEnd != null ? onStepEnd : onStepFinish;
   const jsonSchema2 = await outputStrategy.jsonSchema();
-  const callId = generateId4();
+  const callId = generateId5();
   await notify({
     event: {
       callId,
@@ -14590,7 +14604,7 @@ async function generateObject(options) {
       })
     );
     const responseData = {
-      id: (_b25 = (_a25 = generateResult.response) == null ? void 0 : _a25.id) != null ? _b25 : generateId4(),
+      id: (_b25 = (_a25 = generateResult.response) == null ? void 0 : _a25.id) != null ? _b25 : generateId5(),
       timestamp: (_d = (_c = generateResult.response) == null ? void 0 : _c.timestamp) != null ? _d : currentDate(),
       modelId: (_f = (_e = generateResult.response) == null ? void 0 : _e.modelId) != null ? _f : model.modelId,
       headers: (_g = generateResult.response) == null ? void 0 : _g.headers,
@@ -14850,7 +14864,7 @@ function streamObject(options) {
     },
     onFinish,
     _internal: {
-      generateId: generateId4 = originalGenerateId5,
+      generateId: generateId5 = originalGenerateId5,
       currentDate = () => /* @__PURE__ */ new Date(),
       now: now2 = now
     } = {},
@@ -14897,7 +14911,7 @@ function streamObject(options) {
     onError,
     onFinish,
     download: download2,
-    generateId: generateId4,
+    generateId: generateId5,
     currentDate,
     now: now2
   });
@@ -14926,7 +14940,7 @@ var DefaultStreamObjectResult = class {
     onError,
     onFinish,
     download: download2,
-    generateId: generateId4,
+    generateId: generateId5,
     currentDate,
     now: now2
   }) {
@@ -14960,7 +14974,7 @@ var DefaultStreamObjectResult = class {
       }
     });
     this.baseStream = stitchableStream.stream.pipeThrough(eventProcessor);
-    const callId = generateId4();
+    const callId = generateId5();
     (async () => {
       const jsonSchema2 = await outputStrategy.jsonSchema();
       await notify({
@@ -15058,7 +15072,7 @@ var DefaultStreamObjectResult = class {
       let accumulatedText = "";
       let textDelta = "";
       let fullResponse = {
-        id: generateId4(),
+        id: generateId5(),
         timestamp: currentDate(),
         modelId: model.modelId
       };
@@ -17022,6 +17036,9 @@ function resolveRealtimeToolDescription({
   });
 }
 
+// src/realtime/realtime-session.ts
+import { UnsupportedFunctionalityError as UnsupportedFunctionalityError6 } from "@ai-sdk/provider";
+
 // src/realtime/browser-realtime-audio.ts
 var BrowserRealtimeAudio = class {
   constructor(options) {
@@ -17029,16 +17046,23 @@ var BrowserRealtimeAudio = class {
     this.captureProcessor = null;
     this.captureSource = null;
     this.captureStream = null;
+    this.ownsCaptureStream = true;
+    this.captureCleanup = [];
+    this.captureGeneration = 0;
     this.playbackContext = null;
     this.playbackQueue = [];
     this.playbackTime = 0;
     this.playbackStartTime = 0;
     this.activeSources = /* @__PURE__ */ new Set();
     this.isPlaying = false;
+    this.playbackPaused = false;
+    var _a25;
     this.captureSampleRate = options.captureSampleRate;
     this.playbackSampleRate = options.playbackSampleRate;
     this.onAudio = options.onAudio;
     this.onPlayingChange = options.onPlayingChange;
+    this.maxPlaybackSeconds = (_a25 = options.maxPlaybackSeconds) != null ? _a25 : Infinity;
+    this.onError = options.onError;
     this.onCapturingChange = options.onCapturingChange;
   }
   ensurePlaybackContext() {
@@ -17046,35 +17070,97 @@ var BrowserRealtimeAudio = class {
       this.playbackContext = new AudioContext({
         sampleRate: this.playbackSampleRate
       });
+      const context = this.playbackContext;
+      context.onstatechange = () => {
+        if (this.playbackContext === context)
+          this.setPlaying(
+            context.state === "running" && this.activeSources.size > 0
+          );
+      };
     }
   }
-  startCapture(stream) {
+  async resumePlayback() {
+    var _a25;
+    this.ensurePlaybackContext();
+    const context = this.playbackContext;
+    if (this.playbackPaused) this.stopPlayback();
+    if (this.playbackContext !== context) return;
+    await (context == null ? void 0 : context.resume());
+    if (this.playbackContext !== context) return;
+    this.playbackPaused = false;
+    this.setPlaying(
+      ((_a25 = this.playbackContext) == null ? void 0 : _a25.state) === "running" && this.activeSources.size > 0
+    );
+  }
+  startCapture(stream, options) {
+    var _a25, _b25;
+    const generation = this.captureGeneration + 1;
+    this.stopCapture();
+    if (generation !== this.captureGeneration) {
+      if ((_a25 = options == null ? void 0 : options.ownsStream) != null ? _a25 : true)
+        stream.getTracks().forEach((track) => track.stop());
+      return;
+    }
+    this.captureStream = stream;
+    this.ownsCaptureStream = (_b25 = options == null ? void 0 : options.ownsStream) != null ? _b25 : true;
     const ctx = new AudioContext({ sampleRate: this.captureSampleRate });
     this.captureContext = ctx;
-    this.captureStream = stream;
+    void ctx.resume().catch((error) => {
+      var _a26;
+      if (this.captureContext === ctx) (_a26 = this.onError) == null ? void 0 : _a26.call(this, error);
+    });
     const source = ctx.createMediaStreamSource(stream);
     this.captureSource = source;
-    const processor = ctx.createScriptProcessor(4096, 1, 1);
+    const processor = ctx.createScriptProcessor(1024, 1, 1);
     this.captureProcessor = processor;
     processor.onaudioprocess = (event) => {
+      var _a26;
+      if (this.captureContext !== ctx) return;
       const inputData = event.inputBuffer.getChannelData(0);
       const samples = resampleAudio(
         new Float32Array(inputData),
         ctx.sampleRate,
         this.captureSampleRate
       );
-      this.onAudio(encodeRealtimeAudio(samples));
+      try {
+        this.onAudio(encodeRealtimeAudio(samples));
+      } catch (error) {
+        (_a26 = this.onError) == null ? void 0 : _a26.call(
+          this,
+          error instanceof Error ? error : new Error(String(error))
+        );
+      }
     };
     source.connect(processor);
     processor.connect(ctx.destination);
-    this.onCapturingChange(true);
+    const updateCapturing = () => this.onCapturingChange(
+      stream.getAudioTracks().some(
+        (track) => track.enabled && !track.muted && track.readyState === "live"
+      )
+    );
+    for (const track of stream.getAudioTracks()) {
+      for (const event of ["ended", "mute", "unmute"]) {
+        track.addEventListener(event, updateCapturing);
+        this.captureCleanup.push(
+          () => track.removeEventListener(event, updateCapturing)
+        );
+      }
+    }
+    updateCapturing();
   }
   stopCapture() {
     var _a25, _b25, _c, _d;
+    this.captureGeneration++;
+    if (this.captureProcessor != null)
+      this.captureProcessor.onaudioprocess = null;
+    for (const cleanup of this.captureCleanup) cleanup();
+    this.captureCleanup = [];
     (_a25 = this.captureProcessor) == null ? void 0 : _a25.disconnect();
     (_b25 = this.captureSource) == null ? void 0 : _b25.disconnect();
-    void ((_c = this.captureContext) == null ? void 0 : _c.close());
-    (_d = this.captureStream) == null ? void 0 : _d.getTracks().forEach((track) => track.stop());
+    void ((_c = this.captureContext) == null ? void 0 : _c.close().catch(() => {
+    }));
+    if (this.ownsCaptureStream)
+      (_d = this.captureStream) == null ? void 0 : _d.getTracks().forEach((track) => track.stop());
     this.captureProcessor = null;
     this.captureSource = null;
     this.captureContext = null;
@@ -17082,15 +17168,34 @@ var BrowserRealtimeAudio = class {
     this.onCapturingChange(false);
   }
   playAudio(base64Audio) {
+    var _a25, _b25, _c;
+    if (this.playbackPaused) return;
     this.ensurePlaybackContext();
-    this.playbackQueue.push(decodeRealtimeAudio(base64Audio));
+    const samples = decodeRealtimeAudio(base64Audio);
+    if (Math.max(
+      0,
+      this.playbackTime - ((_b25 = (_a25 = this.playbackContext) == null ? void 0 : _a25.currentTime) != null ? _b25 : 0)
+    ) + samples.length / this.playbackSampleRate > this.maxPlaybackSeconds) {
+      this.playbackPaused = true;
+      this.stopPlayback();
+      (_c = this.onError) == null ? void 0 : _c.call(
+        this,
+        new Error(
+          "Realtime audio playback buffer is full; playback paused, call resumePlayback() to resume at the live edge"
+        )
+      );
+      return;
+    }
+    this.playbackQueue.push(samples);
     this.schedulePlayback();
   }
   stopPlayback() {
     this.playbackQueue = [];
     for (const source of this.activeSources) {
       try {
+        source.onended = null;
         source.stop();
+        source.disconnect();
       } catch (e) {
       }
     }
@@ -17109,8 +17214,12 @@ var BrowserRealtimeAudio = class {
     var _a25;
     this.stopCapture();
     this.stopPlayback();
-    void ((_a25 = this.playbackContext) == null ? void 0 : _a25.close());
+    if (this.playbackContext != null) this.playbackContext.onstatechange = null;
+    void ((_a25 = this.playbackContext) == null ? void 0 : _a25.close().catch(() => {
+    }));
     this.playbackContext = null;
+    this.playbackTime = 0;
+    this.playbackPaused = false;
   }
   setPlaying(isPlaying) {
     var _a25, _b25;
@@ -17140,8 +17249,10 @@ var BrowserRealtimeAudio = class {
       source.start(startTime);
       this.playbackTime = startTime + buffer.duration;
       this.activeSources.add(source);
-      this.setPlaying(true);
+      this.setPlaying(ctx.state === "running");
+      if (this.playbackContext !== ctx) return;
       source.onended = () => {
+        source.disconnect();
         this.activeSources.delete(source);
         if (this.playbackQueue.length === 0 && this.activeSources.size === 0) {
           this.setPlaying(false);
@@ -17151,168 +17262,1323 @@ var BrowserRealtimeAudio = class {
   }
 };
 
-// src/realtime/browser-realtime-transport.ts
+// src/realtime/realtime-event-channel.ts
 import { safeParseJSON as safeParseJSON5 } from "@ai-sdk/provider-utils";
+var RealtimeEventChannel = class {
+  constructor(options) {
+    this.options = options;
+    this.active = true;
+    this.finishing = false;
+    this.incoming = Promise.resolve();
+    this.outgoing = Promise.resolve();
+    this.incomingCount = 0;
+    this.incomingBytes = 0;
+    this.outgoingCount = 0;
+    var _a25, _b25, _c;
+    this.parse = (_c = (_b25 = (_a25 = options.model).createServerEventParser) == null ? void 0 : _b25.call(_a25)) != null ? _c : options.model.parseServerEvent.bind(options.model);
+  }
+  dispose() {
+    this.active = false;
+  }
+  /** Stop accepting messages, but deliver already received terminal events. */
+  async finish() {
+    this.stopWriting();
+    await this.incoming;
+    this.dispose();
+  }
+  stopWriting() {
+    this.finishing = true;
+  }
+  send(event, shouldSend) {
+    var _a25;
+    if (!this.active || this.finishing)
+      throw new Error("Realtime connection is closed");
+    if (this.outgoingCount >= ((_a25 = this.options.maxPending) != null ? _a25 : 512)) {
+      throw new Error("Realtime outgoing queue is full");
+    }
+    this.outgoingCount++;
+    const operation = this.outgoing.then(async () => {
+      if (!this.active || this.finishing)
+        throw new Error("Realtime connection is closed");
+      if ((shouldSend == null ? void 0 : shouldSend()) === false) return;
+      if (!this.active || this.finishing)
+        throw new Error("Realtime connection is closed");
+      const data = await this.options.model.serializeClientEvent(event);
+      if (!this.active || this.finishing)
+        throw new Error("Realtime connection is closed");
+      if ((shouldSend == null ? void 0 : shouldSend()) === false) return;
+      if (!this.active || this.finishing)
+        throw new Error("Realtime connection is closed");
+      if (data != null) this.options.send(data);
+    });
+    this.outgoing = operation.catch((error) => {
+      if (!this.finishing) {
+        if (event.type !== "input-audio-append" && event.type !== "session-close")
+          this.report(error);
+      }
+    }).finally(() => {
+      this.outgoingCount--;
+    });
+    return operation;
+  }
+  receive(data) {
+    var _a25, _b25, _c;
+    if (!this.active || this.finishing) return;
+    const bytes = typeof data === "string" ? data.length * 2 : data instanceof Blob ? data.size : (_a25 = data.byteLength) != null ? _a25 : 0;
+    if (this.incomingCount >= ((_b25 = this.options.maxPending) != null ? _b25 : 512) || this.incomingBytes + bytes > ((_c = this.options.maxPendingBytes) != null ? _c : 8 * 1024 * 1024)) {
+      this.finishing = true;
+      this.fatal(
+        new Error(
+          "Realtime incoming queue is full; input protocol continuity was lost"
+        )
+      );
+      return;
+    }
+    this.incomingCount++;
+    this.incomingBytes += bytes;
+    this.incoming = this.incoming.then(async () => {
+      var _a26, _b26;
+      if (!this.active) return;
+      const text2 = typeof data === "string" ? data : data instanceof Blob ? await data.text() : new TextDecoder().decode(data);
+      const parsed = await safeParseJSON5({ text: text2 });
+      if (!this.active) return;
+      if (!parsed.success)
+        throw new Error("Invalid JSON in realtime server message", {
+          cause: parsed.error
+        });
+      const health = (_b26 = (_a26 = this.options.model).getHealthCheckResponse) == null ? void 0 : _b26.call(
+        _a26,
+        parsed.value
+      );
+      if (!this.active) return;
+      if (health != null && !this.finishing) this.options.send(health);
+      if (!this.active) return;
+      const result = this.parse(parsed.value);
+      for (const event of Array.isArray(result) ? result : [result]) {
+        if (!this.active) return;
+        try {
+          await this.options.onEvent(event);
+        } catch (error) {
+          this.report(error);
+        }
+      }
+    }).catch((error) => {
+      this.finishing = true;
+      this.fatal(error instanceof Error ? error : new Error(String(error)));
+    }).finally(() => {
+      this.incomingCount--;
+      this.incomingBytes -= bytes;
+    });
+  }
+  fatal(error) {
+    if (!this.active) return;
+    if (this.options.onFatalError != null) this.options.onFatalError(error);
+    else this.report(error);
+  }
+  report(error) {
+    if (!this.active) return;
+    try {
+      this.options.onError(
+        error instanceof Error ? error : new Error(String(error))
+      );
+    } catch (e) {
+    }
+  }
+};
+
+// src/realtime/encode-realtime-frame.ts
+var REALTIME_MAX_FRAME_BYTES = 128 * 1024;
+var REALTIME_MAX_BUFFERED_BYTES = 128 * 1024;
+function encodeRealtimeFrame(value) {
+  if (value instanceof ArrayBuffer || ArrayBuffer.isView(value))
+    return { data: value, byteLength: value.byteLength };
+  if (value instanceof Blob) return { data: value, byteLength: value.size };
+  const data = typeof value === "string" ? value : JSON.stringify(value);
+  if (data === void 0)
+    throw new Error("Realtime event could not be encoded as JSON");
+  return { data, byteLength: new TextEncoder().encode(data).byteLength };
+}
+function assertRealtimeFrameBudget(frame, bufferedAmount) {
+  if (frame.byteLength > REALTIME_MAX_FRAME_BYTES)
+    throw new Error(
+      `Realtime frame exceeds the ${REALTIME_MAX_FRAME_BYTES}-byte limit; reduce the event payload`
+    );
+  if (bufferedAmount + frame.byteLength > REALTIME_MAX_BUFFERED_BYTES)
+    throw new Error(
+      `Realtime send buffer is full (${REALTIME_MAX_BUFFERED_BYTES}-byte limit); wait before retrying`
+    );
+}
+
+// src/realtime/browser-realtime-transport.ts
+function getCloseError(event) {
+  if (event.code === 1e3 && event.wasClean) return void 0;
+  return new Error(
+    `Realtime WebSocket closed unexpectedly (code ${event.code}${event.reason === "" ? "" : `: ${event.reason}`})`
+  );
+}
 var BrowserRealtimeTransport = class {
   constructor(options) {
+    this.options = options;
     this.ws = null;
-    this.sendQueue = Promise.resolve();
+    this.epoch = 0;
+    this.failing = false;
+    this.closing = false;
+    var _a25;
     this.model = options.model;
+    this.continuous = ((_a25 = options.model.capabilities) == null ? void 0 : _a25.conversation) === "continuous";
     this.onServerEvent = options.onServerEvent;
     this.onError = options.onError;
     this.onClose = options.onClose;
   }
+  get isOpen() {
+    var _a25;
+    return !this.closing && !this.failing && ((_a25 = this.ws) == null ? void 0 : _a25.readyState) === WebSocket.OPEN;
+  }
   connect({
+    mode,
     token,
     url,
-    onOpen
+    onOpen,
+    protocols
   }) {
-    var _a25;
-    (_a25 = this.ws) == null ? void 0 : _a25.close();
-    this.ws = null;
-    const wsConfig = this.model.getWebSocketConfig({ token, url });
-    const ws = new WebSocket(wsConfig.url, wsConfig.protocols);
+    var _a25, _b25;
+    this.disconnect();
+    const epoch = this.epoch;
+    if (mode !== "relay" && (mode !== "client-secret" || typeof token !== "string" || token.trim() === ""))
+      throw new Error(
+        "Realtime client-secret connection requires a nonempty token"
+      );
+    const wsConfig = mode === "relay" ? { url, protocols } : (_b25 = (_a25 = this.model).getWebSocketConfig) == null ? void 0 : _b25.call(_a25, { token, url });
+    if (this.epoch !== epoch) return;
+    if (wsConfig == null)
+      throw new Error("Model does not support client-secret WebSockets");
+    const finalUrl = wsConfig.url;
+    const finalProtocols = wsConfig.protocols;
+    if (this.epoch !== epoch) return;
+    try {
+      if (typeof finalUrl !== "string" || !/^wss?:\/\//i.test(finalUrl))
+        throw new Error("Invalid realtime WebSocket URL");
+      const parsed = new URL(finalUrl);
+      if (!["ws:", "wss:"].includes(parsed.protocol) || parsed.hostname === "" || finalUrl.includes("#"))
+        throw new Error("Invalid realtime WebSocket URL");
+    } catch (e) {
+      throw new Error(
+        "Invalid realtime WebSocket URL; expected an absolute ws:// or wss:// URL with a host and no fragment"
+      );
+    }
+    if (this.epoch !== epoch) return;
+    const ws = new WebSocket(finalUrl, finalProtocols);
     this.ws = ws;
+    let starting = false;
+    let connectionError;
+    const codec = new RealtimeEventChannel({
+      model: this.model,
+      send: (data) => {
+        if (this.epoch !== epoch || this.ws !== ws || !this.isOpen)
+          throw new Error("Realtime WebSocket is not open");
+        this.sendRaw(data);
+      },
+      onEvent: this.onServerEvent,
+      onError: (error) => {
+        if (!starting) this.onError(error);
+      },
+      onFatalError: (error) => this.fail(error)
+    });
+    if (this.epoch !== epoch) {
+      codec.dispose();
+      return;
+    }
+    this.codec = codec;
     ws.onopen = () => {
       if (this.ws !== ws) return;
-      onOpen();
+      starting = true;
+      try {
+        void Promise.resolve(onOpen()).catch((error) => {
+          if (this.ws === ws)
+            this.fail(
+              error instanceof Error ? error : new Error(String(error))
+            );
+        }).finally(() => {
+          starting = false;
+        });
+      } catch (error) {
+        if (this.epoch === epoch)
+          this.fail(error instanceof Error ? error : new Error(String(error)));
+      }
     };
     ws.onmessage = (messageEvent) => {
-      void this.handleMessage(messageEvent);
+      var _a26;
+      if (this.ws === ws) (_a26 = this.codec) == null ? void 0 : _a26.receive(messageEvent.data);
     };
     ws.onerror = () => {
-      this.onError(new Error("WebSocket connection error"));
+      if (this.ws === ws) {
+        connectionError = new Error("WebSocket connection error");
+        this.failing = true;
+      }
     };
-    ws.onclose = () => {
+    ws.onclose = (event) => {
+      var _a26;
       if (this.ws === ws) {
         this.ws = null;
-        this.onClose();
+        const closeError = (_a26 = getCloseError(event)) != null ? _a26 : connectionError;
+        codec.stopWriting();
+        this.notifyClosing();
+        if (this.epoch !== epoch) return;
+        const complete = () => {
+          if (this.epoch !== epoch) return;
+          clearTimeout(this.drainTimer);
+          this.epoch++;
+          codec.dispose();
+          try {
+            this.onClose(closeError);
+          } catch (error) {
+            this.reportCallbackError(error);
+          }
+        };
+        this.drainTimer = setTimeout(complete, 1e3);
+        void this.awaitDrain(codec.finish(), complete);
       }
     };
   }
   disconnect() {
     var _a25;
-    (_a25 = this.ws) == null ? void 0 : _a25.close();
+    this.epoch++;
+    clearTimeout(this.drainTimer);
+    const ws = this.ws;
     this.ws = null;
+    (_a25 = this.codec) == null ? void 0 : _a25.dispose();
+    this.codec = void 0;
+    this.failing = false;
+    this.closing = false;
+    ws == null ? void 0 : ws.close();
+  }
+  sendEvent(event, shouldSend, automaticAudio = false) {
+    if (this.failing || this.closing)
+      throw new Error("Realtime connection is closed");
+    if (this.codec == null) return Promise.resolve();
+    const epoch = this.epoch;
+    const failed = (error) => {
+      if (automaticAudio && this.epoch === epoch && this.isOpen)
+        this.fail(error instanceof Error ? error : new Error(String(error)));
+    };
+    try {
+      const sent = this.codec.send(event, shouldSend);
+      void sent.catch(failed);
+      return sent;
+    } catch (error) {
+      failed(error);
+      throw error;
+    }
   }
-  sendEvent(event) {
-    this.sendQueue = this.sendQueue.then(async () => {
-      const serialized = await this.model.serializeClientEvent(event);
-      if (serialized != null) {
-        this.sendRaw(serialized);
-      }
-    }).catch((error) => {
-      this.onError(
-        error instanceof Error ? error : new Error(`Failed to send realtime event: ${String(error)}`)
-      );
-    });
+  finish() {
+    var _a25, _b25;
+    return (_b25 = (_a25 = this.codec) == null ? void 0 : _a25.finish()) != null ? _b25 : Promise.resolve();
   }
-  sendRaw(data) {
+  /** Drain accepted events when media or protocol continuity is lost. */
+  fail(error) {
     var _a25;
-    if (((_a25 = this.ws) == null ? void 0 : _a25.readyState) === WebSocket.OPEN) {
-      if (typeof data === "string" || data instanceof ArrayBuffer || ArrayBuffer.isView(data) || data instanceof Blob) {
-        this.ws.send(data);
-      } else {
-        this.ws.send(JSON.stringify(data));
-      }
+    if (this.failing) return;
+    this.failing = true;
+    const epoch = this.epoch;
+    const ws = this.ws;
+    this.ws = null;
+    (_a25 = this.codec) == null ? void 0 : _a25.stopWriting();
+    ws == null ? void 0 : ws.close();
+    this.notifyClosing();
+    if (this.epoch !== epoch) return;
+    const drain = this.finish();
+    if (this.options.onFatalError != null)
+      this.options.onFatalError(error, drain);
+    else {
+      const complete = () => {
+        if (epoch !== this.epoch) return;
+        this.disconnect();
+        try {
+          this.onClose();
+        } catch (cause) {
+          this.reportCallbackError(cause);
+        }
+      };
+      this.drainTimer = setTimeout(complete, 1e3);
+      void this.awaitDrain(drain, complete);
+      this.reportCallbackError(error);
     }
   }
-  dispose() {
-    this.disconnect();
+  notifyClosing() {
+    var _a25, _b25;
+    if (this.closing) return;
+    this.closing = true;
+    try {
+      (_b25 = (_a25 = this.options).onClosing) == null ? void 0 : _b25.call(_a25);
+    } catch (error) {
+      this.reportCallbackError(error);
+    }
   }
-  async handleMessage(messageEvent) {
-    let text2;
-    if (typeof messageEvent.data === "string") {
-      text2 = messageEvent.data;
-    } else if (messageEvent.data instanceof Blob) {
-      text2 = await messageEvent.data.text();
-    } else {
-      text2 = new TextDecoder().decode(messageEvent.data);
+  async awaitDrain(drain, complete) {
+    try {
+      await drain;
+    } catch (e) {
     }
-    const parseResult = await safeParseJSON5({ text: text2 });
-    if (!parseResult.success) return;
-    const rawEvent = parseResult.value;
-    if (this.model.getHealthCheckResponse != null) {
-      const autoResponse = this.model.getHealthCheckResponse(rawEvent);
-      if (autoResponse != null) {
-        this.sendRaw(autoResponse);
-      }
+    try {
+      complete();
+    } catch (error) {
+      this.reportCallbackError(error);
     }
-    const result = this.model.parseServerEvent(rawEvent);
-    const events = Array.isArray(result) ? result : [result];
-    for (const event of events) {
-      await this.onServerEvent(event);
+  }
+  reportCallbackError(error) {
+    try {
+      this.onError(error instanceof Error ? error : new Error(String(error)));
+    } catch (e) {
     }
   }
+  sendRaw(data) {
+    const ws = this.ws;
+    const epoch = this.epoch;
+    if (ws == null || !this.isOpen) return;
+    const frame = encodeRealtimeFrame(data);
+    if (this.epoch !== epoch || this.ws !== ws || !this.isOpen)
+      throw new Error("Realtime connection is closed");
+    if (this.continuous) assertRealtimeFrameBudget(frame, ws.bufferedAmount);
+    ws.send(frame.data);
+  }
+  dispose() {
+    this.disconnect();
+  }
 };
 
-// src/realtime/realtime-event-reducer.ts
-import { safeParseJSON as safeParseJSON6 } from "@ai-sdk/provider-utils";
-function createInitialRealtimeState() {
-  return {
-    status: "disconnected",
-    messages: [],
-    events: [],
-    isCapturing: false,
-    isPlaying: false
-  };
-}
-var RealtimeEventReducer = class {
-  constructor(maxEvents = 500) {
-    this.maxEvents = maxEvents;
-    this.currentAssistantMessageId = null;
-    this.textAccumulators = /* @__PURE__ */ new Map();
-    this.toolArgAccumulators = /* @__PURE__ */ new Map();
-    this.toolCallIdToMessageId = /* @__PURE__ */ new Map();
-    this.toolCallIdToName = /* @__PURE__ */ new Map();
-    this.inputAudioMessageInsertIndex = /* @__PURE__ */ new Map();
-    this.itemIdToPartLocation = /* @__PURE__ */ new Map();
-  }
-  setStatus(state, status) {
-    return { ...state, status };
+// src/realtime/browser-realtime-live-websocket.ts
+import { UnsupportedFunctionalityError as UnsupportedFunctionalityError5 } from "@ai-sdk/provider";
+var BrowserRealtimeLiveWebSocket = class {
+  constructor(options) {
+    this.options = options;
+    this.generation = 0;
+    this.ready = false;
+    this.capturingStarted = false;
+    this.pendingAudio = 0;
+    this.captureGeneration = 0;
+    this.captureEnabled = true;
+    var _a25, _b25, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+    const input = (_a25 = options.sessionConfig) == null ? void 0 : _a25.inputAudioFormat;
+    const output = (_b25 = options.sessionConfig) == null ? void 0 : _b25.outputAudioFormat;
+    const sampleRate = (_e = (_d = (_c = input == null ? void 0 : input.rate) != null ? _c : output == null ? void 0 : output.rate) != null ? _d : options.sampleRate) != null ? _e : 24e3;
+    const format = {
+      type: (_g = (_f = input == null ? void 0 : input.type) != null ? _f : output == null ? void 0 : output.type) != null ? _g : "audio/pcm",
+      rate: sampleRate
+    };
+    this.config = {
+      ...options.sessionConfig,
+      inputAudioFormat: {
+        ...format,
+        ...input
+      },
+      outputAudioFormat: {
+        ...format,
+        ...output
+      }
+    };
+    this.transport = new BrowserRealtimeTransport({
+      model: options.model,
+      onServerEvent: options.onEvent,
+      onError: options.onError,
+      onFatalError: options.onFatalError,
+      onClosing: () => {
+        var _a26;
+        const generation = this.generation;
+        (_a26 = options.onClosing) == null ? void 0 : _a26.call(options);
+        if (generation === this.generation) this.stopCapture();
+      },
+      onClose: options.onClose
+    });
+    this.audio = new BrowserRealtimeAudio({
+      captureSampleRate: (_i = (_h = this.config.inputAudioFormat) == null ? void 0 : _h.rate) != null ? _i : sampleRate,
+      playbackSampleRate: (_k = (_j = this.config.outputAudioFormat) == null ? void 0 : _j.rate) != null ? _k : sampleRate,
+      maxPlaybackSeconds: (_l = options.maxPlaybackBufferSeconds) != null ? _l : 2,
+      onAudio: (audio) => this.sendAudio(audio),
+      onError: options.onError,
+      onCapturingChange: options.onCapturing,
+      onPlayingChange: options.onPlaying
+    });
   }
-  setCapturing(state, isCapturing) {
-    return { ...state, isCapturing };
+  connect(options) {
+    const generation = this.generation + 1;
+    this.dispose();
+    if (generation !== this.generation) return;
+    for (const format of [
+      this.config.inputAudioFormat,
+      this.config.outputAudioFormat
+    ]) {
+      if ((format == null ? void 0 : format.type) !== "audio/pcm")
+        throw new UnsupportedFunctionalityError5({
+          functionality: "Continuous browser WebSocket audio supports PCM16 only"
+        });
+      if (format.rate == null || !Number.isFinite(format.rate) || format.rate < 8e3 || format.rate > 96e3)
+        throw new Error("Invalid realtime PCM sample rate");
+    }
+    this.stream = options.stream;
+    this.captureEnabled = options.capture !== false;
+    this.audio.ensurePlaybackContext();
+    void this.audio.resumePlayback().catch((error) => {
+      if (generation === this.generation) this.options.onError(error);
+    });
+    this.transport.connect({
+      mode: "relay",
+      url: options.url,
+      protocols: options.protocols,
+      onOpen: () => {
+        var _a25, _b25;
+        return this.transport.sendEvent({
+          type: (_b25 = (_a25 = this.options.model.capabilities) == null ? void 0 : _a25.startup) != null ? _b25 : "session-update",
+          config: this.config
+        });
+      }
+    });
   }
-  setPlaying(state, isPlaying) {
-    return { ...state, isPlaying };
+  startCapture() {
+    this.ready = true;
+    if (!this.captureEnabled || this.capturingStarted) return;
+    void this.resumeCapture().catch((error) => this.options.onError(error));
   }
-  addUserTextMessage(state, text2) {
-    return {
-      ...state,
-      messages: [
-        ...state.messages,
-        {
-          id: `user-${Date.now()}`,
-          role: "user",
-          parts: [{ type: "text", text: text2, state: "done" }]
-        }
-      ]
-    };
+  async resumeCapture(suppliedStream) {
+    const generation = this.captureGeneration + 1;
+    this.stopCapture();
+    if (generation !== this.captureGeneration) return;
+    this.ready = true;
+    this.capturingStarted = true;
+    this.captureEnabled = true;
+    if (suppliedStream != null) this.stream = suppliedStream;
+    const supplied = this.stream;
+    const stream = supplied != null ? supplied : await navigator.mediaDevices.getUserMedia({ audio: true });
+    if (generation !== this.captureGeneration || !this.ready) {
+      if (supplied == null) stream.getTracks().forEach((track) => track.stop());
+      return;
+    }
+    if (!stream.getAudioTracks().some((track) => track.readyState === "live")) {
+      if (supplied == null) stream.getTracks().forEach((track) => track.stop());
+      throw new Error("Realtime requires a live audio track");
+    }
+    this.audio.startCapture(stream, { ownsStream: supplied == null });
   }
-  addToolOutput(state, callId, result) {
-    return {
-      state: this.updateToolPartState(state, callId, result),
-      output: {
-        callId,
-        name: this.toolCallIdToName.get(callId),
-        output: JSON.stringify(result)
+  sendAudio(audio) {
+    if (!this.ready || !this.transport.isOpen) return;
+    if (this.pendingAudio >= 8) {
+      this.transport.fail(new Error("Realtime audio send queue is full"));
+      return;
+    }
+    const generation = this.generation;
+    let sent;
+    try {
+      sent = this.transport.sendEvent(
+        { type: "input-audio-append", audio },
+        void 0,
+        true
+      );
+    } catch (error) {
+      if (!this.ready || !this.transport.isOpen) return;
+      throw error;
+    }
+    this.pendingAudio++;
+    void sent.then(
+      () => {
+        if (generation === this.generation) this.pendingAudio--;
+      },
+      (error) => {
+        if (generation === this.generation && this.ready && this.transport.isOpen)
+          this.options.onFatalError(error);
       }
-    };
+    );
   }
-  async reduceServerEvent(state, event) {
-    var _a25;
-    let nextState = this.pushEvent(state, event);
-    const effects = [];
-    switch (event.type) {
-      case "session-created":
-      case "session-updated": {
-        if (nextState.status === "connecting") {
-          nextState = this.setStatus(nextState, "connected");
+  sendEvent(event, shouldSend) {
+    var _a25, _b25;
+    if (event.type === "session-update") {
+      for (const key of ["inputAudioFormat", "outputAudioFormat"]) {
+        const update = event.config[key];
+        if (update != null && (update.type !== ((_a25 = this.config[key]) == null ? void 0 : _a25.type) || update.rate != null && update.rate !== ((_b25 = this.config[key]) == null ? void 0 : _b25.rate))) {
+          throw new Error(
+            "Changing Live WebSocket audio format requires reconnecting"
+          );
         }
-        break;
       }
-      case "audio-delta": {
+    }
+    return this.transport.sendEvent(event, shouldSend);
+  }
+  playAudio(audio) {
+    try {
+      this.audio.playAudio(audio);
+    } catch (error) {
+      this.options.onError(
+        error instanceof Error ? error : new Error(String(error))
+      );
+    }
+  }
+  stopPlayback() {
+    this.audio.stopPlayback();
+  }
+  resumePlayback() {
+    return this.audio.resumePlayback();
+  }
+  stopCapture() {
+    this.captureGeneration++;
+    this.ready = false;
+    this.capturingStarted = false;
+    this.captureEnabled = false;
+    this.audio.stopCapture();
+  }
+  finish() {
+    return this.transport.finish();
+  }
+  dispose() {
+    this.generation++;
+    this.stopCapture();
+    this.ready = false;
+    this.capturingStarted = false;
+    this.pendingAudio = 0;
+    this.stream = void 0;
+    this.transport.disconnect();
+    this.audio.dispose();
+  }
+};
+
+// src/realtime/browser-realtime-webrtc.ts
+import { safeParseJSON as safeParseJSON6 } from "@ai-sdk/provider-utils";
+var MAX_SESSION_ANSWER_BYTES = 1024 * 1024;
+async function readSessionAnswer(response) {
+  var _a25;
+  const reader = (_a25 = response.body) == null ? void 0 : _a25.getReader();
+  if (reader == null) throw new Error("Invalid realtime session answer");
+  const decoder = new TextDecoder();
+  let bytes = 0;
+  let text2 = "";
+  try {
+    if (Number(response.headers.get("content-length")) > MAX_SESSION_ANSWER_BYTES)
+      throw new Error("Realtime session answer exceeds the 1 MiB limit");
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) return text2 + decoder.decode();
+      bytes += value.byteLength;
+      if (bytes > MAX_SESSION_ANSWER_BYTES)
+        throw new Error("Realtime session answer exceeds the 1 MiB limit");
+      text2 += decoder.decode(value, { stream: true });
+    }
+  } catch (error) {
+    void reader.cancel(error).catch(() => {
+    });
+    throw error;
+  } finally {
+    reader.releaseLock();
+  }
+}
+function selectAudioTrack(stream) {
+  var _a25;
+  const live = stream.getAudioTracks().filter((track) => track.readyState === "live");
+  return (_a25 = live.find((track) => track.enabled && !track.muted)) != null ? _a25 : live[0];
+}
+var BrowserRealtimeWebRTC = class {
+  constructor(options) {
+    this.options = options;
+    this.ownsStream = false;
+    this.generation = 0;
+    this.closingNotified = false;
+    this.captureGeneration = 0;
+    this.senderOperations = Promise.resolve();
+    this.trackCleanups = [];
+  }
+  async connect({
+    api,
+    sessionConfig,
+    stream,
+    timeoutMs,
+    capture = true
+  }) {
+    var _a25, _b25;
+    const generation = this.generation + 1;
+    this.dispose();
+    const current = () => generation === this.generation;
+    if (!current()) return;
+    const config = (_b25 = (_a25 = this.options.model).getWebRTCConfig) == null ? void 0 : _b25.call(_a25);
+    if (!current()) return;
+    if (config == null)
+      throw new Error("This model does not support WebRTC configuration");
+    const abort = new AbortController();
+    this.abort = abort;
+    const timeout = setTimeout(
+      () => abort.abort(new Error("Realtime startup timed out")),
+      timeoutMs
+    );
+    const cancelled = new Promise((_, reject) => {
+      abort.signal.addEventListener(
+        "abort",
+        () => reject(abort.signal.reason),
+        { once: true }
+      );
+    });
+    const start = async () => {
+      var _a26;
+      const captureGeneration = this.captureGeneration;
+      let media = capture ? stream != null ? stream : await navigator.mediaDevices.getUserMedia({ audio: true }) : void 0;
+      if (!current() || abort.signal.aborted) {
+        if (stream == null) media == null ? void 0 : media.getTracks().forEach((track2) => track2.stop());
+        throw new Error("Realtime connection cancelled");
+      }
+      if (captureGeneration !== this.captureGeneration) {
+        if (stream == null) media == null ? void 0 : media.getTracks().forEach((track2) => track2.stop());
+        media = void 0;
+      }
+      this.stream = media;
+      this.ownsStream = stream == null;
+      const track = media == null ? void 0 : selectAudioTrack(media);
+      if (media != null && track == null) {
+        throw new Error("Realtime requires a live audio track");
+      }
+      const pc = new RTCPeerConnection();
+      this.pc = pc;
+      const audio = document.createElement("audio");
+      audio.autoplay = true;
+      this.audio = audio;
+      audio.onplaying = () => {
+        if (current()) this.options.onPlaying(true);
+      };
+      const stopped = () => {
+        if (current()) this.options.onPlaying(false);
+      };
+      audio.onpause = stopped;
+      audio.onended = stopped;
+      audio.onwaiting = stopped;
+      pc.ontrack = (event) => {
+        var _a27;
+        if (!current()) return;
+        audio.srcObject = (_a27 = event.streams[0]) != null ? _a27 : new MediaStream([event.track]);
+        void audio.play().catch((error) => {
+          if (current()) this.options.onError(error);
+        });
+      };
+      pc.onconnectionstatechange = () => {
+        var _a27;
+        if (!current()) return;
+        if (pc.connectionState === "connected")
+          clearTimeout(this.disconnectTimer);
+        else if (pc.connectionState === "disconnected") {
+          clearTimeout(this.disconnectTimer);
+          this.disconnectTimer = setTimeout(() => {
+            if (current() && pc.connectionState === "disconnected")
+              this.fail(
+                new Error(
+                  "Realtime peer disconnected beyond recovery grace period"
+                )
+              );
+          }, (_a27 = this.options.disconnectTimeoutMs) != null ? _a27 : 5e3);
+        } else if (pc.connectionState === "closed") {
+          this.drainClose(new Error("Realtime peer connection closed"));
+        } else if (pc.connectionState === "failed") {
+          this.fail(
+            new Error(`Realtime peer connection ${pc.connectionState}`)
+          );
+        }
+      };
+      pc.oniceconnectionstatechange = () => {
+        if (current() && pc.iceConnectionState === "failed")
+          this.fail(new Error("Realtime ICE connection failed"));
+      };
+      const dc = pc.createDataChannel(config.dataChannelLabel);
+      this.dc = dc;
+      const codec = new RealtimeEventChannel({
+        model: this.options.model,
+        onEvent: this.options.onEvent,
+        onError: this.options.onError,
+        onFatalError: (error) => {
+          if (current()) this.fail(error);
+        },
+        send: (data) => {
+          if (!current() || this.finishing || dc.readyState !== "open")
+            throw new Error("Realtime data channel is not open");
+          if (dc.bufferedAmount > 1024 * 1024)
+            throw new Error("Realtime data channel buffer is full");
+          const encoded = typeof data === "string" ? data : JSON.stringify(data);
+          if (!current() || this.finishing || dc.readyState !== "open")
+            throw new Error("Realtime data channel is not open");
+          dc.send(encoded);
+        }
+      });
+      if (!current()) {
+        codec.dispose();
+        return;
+      }
+      this.codec = codec;
+      dc.onmessage = (event) => {
+        var _a27;
+        if (current()) (_a27 = this.codec) == null ? void 0 : _a27.receive(event.data);
+      };
+      dc.onclose = () => {
+        if (current())
+          this.drainClose(new Error("Realtime data channel closed"));
+      };
+      dc.onerror = () => {
+        if (current()) this.fail(new Error("Realtime data channel error"));
+      };
+      const opened = new Promise((resolve3, reject) => {
+        this.rejectStartup = reject;
+        dc.onopen = () => {
+          this.rejectStartup = void 0;
+          resolve3();
+        };
+      });
+      void opened.catch(() => {
+      });
+      const gathered = new Promise((resolve3) => {
+        pc.onicegatheringstatechange = () => {
+          if (pc.iceGatheringState === "complete") resolve3();
+        };
+      });
+      this.sender = media != null && track != null ? pc.addTrack(track, media) : pc.addTransceiver("audio", { direction: "sendrecv" }).sender;
+      this.observeCapture();
+      if (!current() || abort.signal.aborted) return;
+      const offer = await pc.createOffer();
+      if (!current() || abort.signal.aborted) return;
+      await pc.setLocalDescription(offer);
+      if (pc.iceGatheringState !== "complete")
+        await Promise.race([gathered, cancelled]);
+      if (!current() || abort.signal.aborted) return;
+      const sdp = (_a26 = pc.localDescription) == null ? void 0 : _a26.sdp;
+      if (sdp == null) throw new Error("Realtime offer has no SDP");
+      const response = await fetch(api, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ sdp, sessionConfig }),
+        signal: abort.signal
+      });
+      if (!response.ok)
+        throw new Error(
+          `Failed to create realtime session: ${response.status}`
+        );
+      const parsed = await safeParseJSON6({
+        text: await readSessionAnswer(response)
+      });
+      if (!current() || abort.signal.aborted) return;
+      if (!parsed.success || typeof parsed.value !== "object" || parsed.value == null || !("sdp" in parsed.value) || typeof parsed.value.sdp !== "string" || parsed.value.sdp.trim().length === 0 || !("sessionId" in parsed.value) || typeof parsed.value.sessionId !== "string" || parsed.value.sessionId.trim().length === 0) {
+        throw new Error("Invalid realtime session answer");
+      }
+      await pc.setRemoteDescription({ type: "answer", sdp: parsed.value.sdp });
+      await Promise.race([opened, cancelled]);
+    };
+    try {
+      await Promise.race([start(), cancelled]);
+    } catch (error) {
+      if (current()) this.dispose();
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+      this.rejectStartup = void 0;
+    }
+  }
+  sendEvent(event, shouldSend) {
+    var _a25, _b25, _c;
+    if (this.finishing || ((_a25 = this.dc) == null ? void 0 : _a25.readyState) !== "open")
+      throw new Error("Realtime data channel is not open");
+    return (_c = (_b25 = this.codec) == null ? void 0 : _b25.send(event, shouldSend)) != null ? _c : Promise.resolve();
+  }
+  async resumePlayback() {
+    if (this.audio == null)
+      throw new Error("Realtime playback is not connected");
+    await this.audio.play();
+  }
+  stopPlayback() {
+    var _a25;
+    (_a25 = this.audio) == null ? void 0 : _a25.pause();
+  }
+  finish() {
+    var _a25, _b25;
+    return (_b25 = (_a25 = this.codec) == null ? void 0 : _a25.finish()) != null ? _b25 : Promise.resolve();
+  }
+  fail(error) {
+    var _a25;
+    if (this.finishing === "failure") return;
+    this.finishing = "failure";
+    clearTimeout(this.finishTimer);
+    if (this.rejectStartup != null) {
+      this.rejectStartup(error);
+      (_a25 = this.abort) == null ? void 0 : _a25.abort(error);
+      return;
+    }
+    const generation = this.generation;
+    const drain = this.finish();
+    this.notifyClosing();
+    if (generation !== this.generation) return;
+    void this.stopCaptureForShutdown(generation);
+    if (generation !== this.generation) return;
+    if (this.options.onFatalError != null) {
+      this.options.onFatalError(error, drain);
+      return;
+    }
+    const complete = () => {
+      if (generation !== this.generation) return;
+      this.dispose();
+      try {
+        this.options.onClose();
+      } catch (cause) {
+        this.reportCallbackError(cause);
+      }
+    };
+    this.finishTimer = setTimeout(complete, 1e3);
+    void this.awaitDrain(drain, complete);
+    try {
+      this.options.onError(error);
+    } catch (e) {
+    }
+  }
+  drainClose(error) {
+    if (this.finishing) return;
+    if (this.rejectStartup != null) {
+      this.fail(error);
+      return;
+    }
+    this.finishing = "close";
+    const generation = this.generation;
+    const complete = () => {
+      if (generation !== this.generation || this.finishing !== "close") return;
+      clearTimeout(this.finishTimer);
+      try {
+        this.options.onClose(error);
+      } catch (cause) {
+        this.reportCallbackError(cause);
+      } finally {
+        if (generation === this.generation) this.dispose();
+      }
+    };
+    this.finishTimer = setTimeout(complete, 1e3);
+    void this.awaitDrain(this.finish(), complete);
+    this.notifyClosing();
+    if (generation !== this.generation) return;
+    void this.stopCaptureForShutdown(generation);
+  }
+  notifyClosing() {
+    var _a25, _b25;
+    if (this.closingNotified) return;
+    this.closingNotified = true;
+    try {
+      (_b25 = (_a25 = this.options).onClosing) == null ? void 0 : _b25.call(_a25);
+    } catch (error) {
+      this.reportCallbackError(error);
+    }
+  }
+  async stopCaptureForShutdown(generation) {
+    try {
+      await this.stopCapture();
+    } catch (cause) {
+      if (generation !== this.generation || this.finishing !== "close") return;
+      try {
+        this.fail(cause instanceof Error ? cause : new Error(String(cause)));
+      } catch (error) {
+        this.reportCallbackError(error);
+      }
+    }
+  }
+  async awaitDrain(drain, complete) {
+    try {
+      await drain;
+    } catch (e) {
+    }
+    try {
+      complete();
+    } catch (error) {
+      this.reportCallbackError(error);
+    }
+  }
+  reportCallbackError(error) {
+    try {
+      this.options.onError(
+        error instanceof Error ? error : new Error(String(error))
+      );
+    } catch (e) {
+    }
+  }
+  async stopCapture() {
+    var _a25;
+    const generation = ++this.captureGeneration;
+    for (const cleanup of this.trackCleanups) cleanup();
+    this.trackCleanups = [];
+    if (this.ownsStream)
+      (_a25 = this.stream) == null ? void 0 : _a25.getTracks().forEach((track) => track.stop());
+    this.stream = void 0;
+    const pc = this.pc;
+    const sender = this.sender;
+    await this.queueSenderOperation(async () => {
+      if (pc !== this.pc || sender !== this.sender) return;
+      if (pc != null && sender != null) await this.detachSender(pc, sender);
+      if (generation === this.captureGeneration && pc === this.pc)
+        this.options.onCapturing(false);
+    });
+  }
+  async startCapture(supplied) {
+    const generation = this.captureGeneration + 1;
+    await this.stopCapture();
+    if (generation !== this.captureGeneration || this.pc == null || this.finishing)
+      return;
+    const media = supplied != null ? supplied : await navigator.mediaDevices.getUserMedia({ audio: true });
+    if (generation !== this.captureGeneration || this.pc == null || this.finishing) {
+      if (supplied == null) media.getTracks().forEach((track2) => track2.stop());
+      return;
+    }
+    const track = selectAudioTrack(media);
+    if (track == null) {
+      if (supplied == null) media.getTracks().forEach((track2) => track2.stop());
+      throw new Error("Realtime requires a live audio track");
+    }
+    const pc = this.pc;
+    const sender = this.sender;
+    await this.queueSenderOperation(async () => {
+      const current = () => generation === this.captureGeneration && pc === this.pc && sender === this.sender && pc.connectionState !== "closed" && !this.finishing;
+      let attached = false;
+      try {
+        if (!current() || sender == null) return;
+        await sender.replaceTrack(track);
+        if (!current()) {
+          if (pc === this.pc) await this.detachSender(pc, sender);
+          return;
+        }
+        this.stream = media;
+        this.ownsStream = supplied == null;
+        attached = true;
+        this.observeCapture();
+      } finally {
+        if (!attached && supplied == null)
+          media.getTracks().forEach((track2) => track2.stop());
+      }
+    });
+  }
+  queueSenderOperation(operation) {
+    const pending = this.senderOperations.then(operation);
+    this.senderOperations = pending.catch(() => {
+    });
+    return pending;
+  }
+  async detachSender(pc, sender) {
+    if (pc.connectionState === "closed") return;
+    try {
+      await sender.replaceTrack(null);
+    } catch (error) {
+      if (pc !== this.pc) return;
+      this.closePeer(pc);
+      this.fail(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  closePeer(pc) {
+    pc.ontrack = null;
+    pc.onconnectionstatechange = null;
+    pc.oniceconnectionstatechange = null;
+    pc.onicegatheringstatechange = null;
+    if (pc.connectionState !== "closed") pc.close();
+  }
+  observeCapture() {
+    const generation = this.captureGeneration;
+    const sender = this.sender;
+    const track = sender == null ? void 0 : sender.track;
+    const update = () => {
+      if (generation === this.captureGeneration && this.sender === sender)
+        this.options.onCapturing(
+          (sender == null ? void 0 : sender.track) != null && sender.track.readyState === "live" && sender.track.enabled && !sender.track.muted
+        );
+    };
+    if (track != null) {
+      for (const event of ["ended", "mute", "unmute"]) {
+        track.addEventListener(event, update);
+        this.trackCleanups.push(() => track.removeEventListener(event, update));
+      }
+    }
+    update();
+  }
+  dispose() {
+    var _a25, _b25, _c;
+    this.generation++;
+    this.captureGeneration++;
+    clearTimeout(this.finishTimer);
+    clearTimeout(this.disconnectTimer);
+    this.finishing = void 0;
+    this.closingNotified = false;
+    this.senderOperations = Promise.resolve();
+    (_a25 = this.abort) == null ? void 0 : _a25.abort(new Error("Realtime connection cancelled"));
+    this.abort = void 0;
+    (_b25 = this.codec) == null ? void 0 : _b25.dispose();
+    this.codec = void 0;
+    if (this.dc != null) {
+      this.dc.onopen = null;
+      this.dc.onclose = null;
+      this.dc.onerror = null;
+      this.dc.onmessage = null;
+      this.dc.close();
+      this.dc = void 0;
+    }
+    if (this.pc != null) {
+      this.closePeer(this.pc);
+      this.pc = void 0;
+    }
+    for (const cleanup of this.trackCleanups) cleanup();
+    this.trackCleanups = [];
+    if (this.ownsStream)
+      (_c = this.stream) == null ? void 0 : _c.getTracks().forEach((track) => track.stop());
+    this.stream = void 0;
+    this.sender = void 0;
+    if (this.audio != null) {
+      this.audio.onplaying = null;
+      this.audio.onpause = null;
+      this.audio.onended = null;
+      this.audio.onwaiting = null;
+      this.audio.pause();
+      this.audio.srcObject = null;
+      this.audio = void 0;
+    }
+    this.options.onCapturing(false);
+    this.options.onPlaying(false);
+  }
+};
+
+// src/realtime/realtime-attempt.ts
+var RealtimeAttempt = class {
+  constructor() {
+    this.abort = new AbortController();
+    this.timers = /* @__PURE__ */ new Map();
+    this.active = true;
+    this.ready = false;
+    this.closing = false;
+    this.transportClosing = false;
+  }
+  timer(name25, duration, callback) {
+    this.clearTimer(name25);
+    this.timers.set(
+      name25,
+      setTimeout(() => {
+        this.timers.delete(name25);
+        if (this.active) callback();
+      }, duration)
+    );
+  }
+  clearTimer(name25) {
+    clearTimeout(this.timers.get(name25));
+    this.timers.delete(name25);
+  }
+  beginClose() {
+    var _a25;
+    this.closing = true;
+    return (_a25 = this.closePromise) != null ? _a25 : this.closePromise = new Promise((resolve3) => {
+      this.settleClose = resolve3;
+    });
+  }
+  retire() {
+    var _a25;
+    if (!this.active) return;
+    this.active = false;
+    this.abort.abort();
+    for (const timer of this.timers.values()) clearTimeout(timer);
+    this.timers.clear();
+    (_a25 = this.settleClose) == null ? void 0 : _a25.call(this);
+    this.settleClose = void 0;
+  }
+};
+
+// src/realtime/realtime-command-tracker.ts
+import { generateId as generateId3 } from "@ai-sdk/provider-utils";
+var RealtimeCommandTracker = class {
+  constructor(sendCommand) {
+    this.sendCommand = sendCommand;
+    this.pending = /* @__PURE__ */ new Map();
+    this.recent = /* @__PURE__ */ new Set();
+  }
+  validateId(id) {
+    if (this.pending.has(id) || this.recent.has(id))
+      throw new Error(
+        "Realtime command ID was already used; retry with a fresh eventId"
+      );
+    if (this.pending.size >= 512)
+      throw new Error("Too many pending realtime commands");
+  }
+  complete(id) {
+    const command = this.pending.get(id);
+    if (command == null) return;
+    this.pending.delete(id);
+    this.recent.add(id);
+    if (this.recent.size > 4096) {
+      const oldest = this.recent.values().next().value;
+      if (oldest != null) this.recent.delete(oldest);
+    }
+    return command;
+  }
+  send(event) {
+    var _a25;
+    const muted = event.type === "input-audio-mute" ? true : event.type === "input-audio-unmute" ? false : void 0;
+    if (event.type === "input-audio-mute" || event.type === "input-audio-unmute")
+      event = { ...event, eventId: (_a25 = event.eventId) != null ? _a25 : generateId3() };
+    const id = "eventId" in event ? event.eventId : void 0;
+    if (id != null) {
+      this.validateId(id);
+      this.pending.set(id, { muted });
+    }
+    const awaitsAcknowledgement = event.type === "context-append" || event.type === "session-update" || muted != null;
+    try {
+      const sent = this.sendCommand(event);
+      void sent.then(
+        () => {
+          if (id != null && !awaitsAcknowledgement) this.complete(id);
+        },
+        () => {
+          if (id != null) this.complete(id);
+        }
+      );
+      return sent;
+    } catch (error) {
+      if (id != null) this.complete(id);
+      throw error;
+    }
+  }
+  receive(event) {
+    if (event.type === "command-acknowledged" && event.clientEventId != null)
+      return this.complete(event.clientEventId);
+    if (event.type === "error" && event.clientEventId != null)
+      this.complete(event.clientEventId);
+  }
+};
+
+// src/realtime/validate-realtime-setup.ts
+var setupSchema = z.object({
+  token: z.string().refine((value) => value.trim().length > 0),
+  url: z.string().refine((value) => {
+    try {
+      const url = new URL(value);
+      return (url.protocol === "ws:" || url.protocol === "wss:") && url.hostname !== "";
+    } catch (e) {
+      return false;
+    }
+  }),
+  expiresAt: z.number().positive().max(Number.MAX_SAFE_INTEGER).optional(),
+  tools: z.array(
+    z.object({
+      type: z.literal("function"),
+      name: z.string().min(1),
+      description: z.string().optional(),
+      parameters: z.record(z.string(), z.unknown())
+    })
+  ).optional()
+});
+function validateRealtimeSetup(payload) {
+  const result = setupSchema.safeParse(payload);
+  if (!result.success)
+    throw new Error(
+      "Invalid realtime setup: expected a nonempty token, a ws(s) URL, and valid optional expiresAt/tools"
+    );
+  return result.data;
+}
+
+// src/realtime/realtime-session-state.ts
+function createSessionState() {
+  return {
+    transcripts: [],
+    delegations: [],
+    isInputMuted: false,
+    finalization: "pending"
+  };
+}
+function reduceSessionState(state, event, limit, muted) {
+  var _a25;
+  switch (event.type) {
+    case "session-started":
+      return {
+        ...state,
+        sessionId: event.sessionId,
+        delegationMode: event.delegationMode
+      };
+    case "session-usage":
+      return { ...state, usage: event.usage };
+    case "session-closed":
+      return {
+        ...state,
+        sessionId: (_a25 = event.sessionId) != null ? _a25 : state.sessionId,
+        usage: event.usage,
+        terminationReason: event.reason,
+        finalization: "confirmed"
+      };
+    case "transcript-fragment":
+      return {
+        ...state,
+        transcripts: [...state.transcripts, event].slice(-limit)
+      };
+    case "delegation-created":
+      return state.delegations.some(
+        (item) => item.delegationId === event.delegationId
+      ) ? state : {
+        ...state,
+        delegations: [...state.delegations, event].slice(-limit)
+      };
+    case "command-acknowledged":
+      return muted == null ? state : { ...state, isInputMuted: muted };
+    default:
+      return state;
+  }
+}
+
+// src/realtime/realtime-event-reducer.ts
+import { safeParseJSON as safeParseJSON7 } from "@ai-sdk/provider-utils";
+function createInitialRealtimeState() {
+  return {
+    status: "disconnected",
+    messages: [],
+    events: [],
+    isCapturing: false,
+    isPlaying: false
+  };
+}
+var RealtimeEventReducer = class {
+  constructor(maxEvents = 500) {
+    this.maxEvents = maxEvents;
+    this.currentAssistantMessageId = null;
+    this.textAccumulators = /* @__PURE__ */ new Map();
+    this.toolArgAccumulators = /* @__PURE__ */ new Map();
+    this.toolCallIdToMessageId = /* @__PURE__ */ new Map();
+    this.toolCallIdToName = /* @__PURE__ */ new Map();
+    this.inputAudioMessageInsertIndex = /* @__PURE__ */ new Map();
+    this.itemIdToPartLocation = /* @__PURE__ */ new Map();
+  }
+  setStatus(state, status) {
+    return { ...state, status };
+  }
+  setCapturing(state, isCapturing) {
+    return { ...state, isCapturing };
+  }
+  setPlaying(state, isPlaying) {
+    return { ...state, isPlaying };
+  }
+  addUserTextMessage(state, text2) {
+    return {
+      ...state,
+      messages: [
+        ...state.messages,
+        {
+          id: `user-${Date.now()}`,
+          role: "user",
+          parts: [{ type: "text", text: text2, state: "done" }]
+        }
+      ]
+    };
+  }
+  addToolOutput(state, callId, result) {
+    return {
+      state: this.updateToolPartState(state, callId, result),
+      output: {
+        callId,
+        name: this.toolCallIdToName.get(callId),
+        output: JSON.stringify(result)
+      }
+    };
+  }
+  async reduceServerEvent(state, event) {
+    var _a25;
+    let nextState = this.pushEvent(state, event);
+    const effects = [];
+    switch (event.type) {
+      case "session-created":
+      case "session-updated": {
+        if (nextState.status === "connecting") {
+          nextState = this.setStatus(nextState, "connected");
+        }
+        break;
+      }
+      case "audio-delta": {
         effects.push({
           type: "play-audio",
           itemId: event.itemId,
@@ -17376,7 +18642,7 @@ var RealtimeEventReducer = class {
       case "function-call-arguments-done": {
         this.toolArgAccumulators.delete(event.callId);
         this.toolCallIdToName.set(event.callId, event.name);
-        const parseResult = await safeParseJSON6({ text: event.arguments });
+        const parseResult = await safeParseJSON7({ text: event.arguments });
         const parsedInput = parseResult.success ? parseResult.value : {};
         const messageId = this.toolCallIdToMessageId.get(event.callId);
         if (messageId != null) {
@@ -17616,98 +18882,375 @@ var RealtimeEventReducer = class {
 // src/realtime/realtime-session.ts
 var AbstractRealtimeSession = class {
   constructor(options) {
+    this.options = options;
     this.state = createInitialRealtimeState();
+    this.publication = 0;
+    this.captureGeneration = 0;
+    this.captureRequested = false;
     this.currentResponseItemId = null;
-    // Tool calls requested by the current (tool-bearing) response, the outputs
-    // that have been submitted for them, and whether that response has finished
-    // delivering its tool calls. Used to request a single response only once
-    // every tool output for the turn has been submitted.
     this.toolCallsInResponse = /* @__PURE__ */ new Set();
     this.submittedToolOutputs = /* @__PURE__ */ new Set();
     this.responseToolCallsClosed = false;
-    var _a25, _b25, _c, _d, _e, _f, _g, _h;
-    this.model = options.model;
-    this.api = options.api;
-    this.sessionConfig = options.sessionConfig;
+    var _a25, _b25, _c, _d, _e;
+    const capabilities = options.model.capabilities;
+    this.sessionLifecycle = (capabilities == null ? void 0 : capabilities.startup) === "session-start" || (capabilities == null ? void 0 : capabilities.finalization) === "session-close";
+    this.continuous = (capabilities == null ? void 0 : capabilities.conversation) === "continuous";
     this.maxEvents = (_a25 = options.maxEvents) != null ? _a25 : 500;
+    if (!Number.isSafeInteger(this.maxEvents) || this.maxEvents < 1)
+      throw new Error("maxEvents must be a positive integer");
+    for (const timeout of [
+      (_b25 = options.startupTimeoutMs) != null ? _b25 : 3e4,
+      (_c = options.closeTimeoutMs) != null ? _c : 15e3,
+      (_d = options.rtcDisconnectTimeoutMs) != null ? _d : 5e3
+    ]) {
+      if (!Number.isFinite(timeout) || timeout <= 0 || timeout > 2147483647)
+        throw new Error(
+          "Realtime timeouts must be positive finite timer durations"
+        );
+    }
+    const budget = (_e = options.maxPlaybackBufferSeconds) != null ? _e : 2;
+    if (!Number.isFinite(budget) || budget <= 0)
+      throw new Error("maxPlaybackBufferSeconds must be positive and finite");
     this.reducer = new RealtimeEventReducer(this.maxEvents);
     this.onToolCall = options.onToolCall;
     this.onEvent = options.onEvent;
     this.onError = options.onError;
-    const sampleRate = (_b25 = options.sampleRate) != null ? _b25 : 24e3;
-    const captureSampleRate = (_e = (_d = (_c = options.sessionConfig) == null ? void 0 : _c.inputAudioFormat) == null ? void 0 : _d.rate) != null ? _e : sampleRate;
-    const playbackSampleRate = (_h = (_g = (_f = options.sessionConfig) == null ? void 0 : _f.outputAudioFormat) == null ? void 0 : _g.rate) != null ? _h : sampleRate;
-    this.transport = new BrowserRealtimeTransport({
-      model: this.model,
-      onServerEvent: (event) => this.handleServerEvent(event),
-      onError: (error) => {
-        var _a26;
-        this.applyState(this.reducer.setStatus(this.state, "error"));
-        (_a26 = this.onError) == null ? void 0 : _a26.call(this, error);
-      },
-      onClose: () => {
-        this.applyState(this.reducer.setStatus(this.state, "disconnected"));
-      }
-    });
-    this.audio = new BrowserRealtimeAudio({
-      captureSampleRate,
-      playbackSampleRate,
-      onAudio: (audio) => this.sendAudio(audio),
-      onCapturingChange: (isCapturing) => {
-        this.applyState(this.reducer.setCapturing(this.state, isCapturing));
-      },
-      onPlayingChange: (isPlaying) => {
-        this.applyState(this.reducer.setPlaying(this.state, isPlaying));
-      }
-    });
   }
-  // ── Connection ─────────────────────────────────────────────────────
-  async connect() {
-    var _a25;
-    this.applyState(this.reducer.setStatus(this.state, "connecting"));
+  validateConnection() {
+    var _a25, _b25, _c;
+    const { model, api } = this.options;
+    if ((!this.continuous || api.session != null) && this.options.maxPlaybackBufferSeconds != null)
+      throw new Error(
+        "maxPlaybackBufferSeconds is supported only for continuous PCM sessions"
+      );
+    const connection = api.session != null ? "webrtc" : api.token != null ? "client-secret-websocket" : "server-websocket";
+    if (!((_b25 = (_a25 = model.capabilities) == null ? void 0 : _a25.connections) != null ? _b25 : ["client-secret-websocket"]).includes(connection) || ((_c = model.capabilities) == null ? void 0 : _c.transports) != null && !model.capabilities.transports.includes(
+      api.session != null ? "webrtc" : "websocket"
+    ))
+      throw new Error(`Realtime model does not support ${connection}`);
+    if (api.session != null) {
+      if (model.getWebRTCConfig == null)
+        throw new Error("Realtime model does not support WebRTC configuration");
+      return;
+    }
+    if (this.continuous && api.websocket == null)
+      throw new Error(
+        "Continuous PCM sessions require an application WebSocket relay"
+      );
+    if (api.token != null && model.getWebSocketConfig == null)
+      throw new Error(
+        "Realtime model does not support client-secret WebSocket configuration"
+      );
+  }
+  async connect(connectOptions) {
+    var _a25, _b25, _c, _d;
+    if ((_a25 = this.attempt) == null ? void 0 : _a25.active)
+      throw new Error("Realtime session is already active");
+    const attempt = new RealtimeAttempt();
+    this.attempt = attempt;
+    const current = () => this.attempt === attempt && attempt.active;
     try {
-      const response = await fetch(this.api.token, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ sessionConfig: this.sessionConfig })
+      this.applyState({ ...this.state, status: "connecting" });
+      if (!current()) return;
+      this.validateConnection();
+      const { model, api, sessionConfig } = this.options;
+      if ((connectOptions == null ? void 0 : connectOptions.capture) === false) this.stopAudioCapture();
+      if (!current()) return;
+      if ((connectOptions == null ? void 0 : connectOptions.stream) != null && connectOptions.stream !== this.suppliedStream) {
+        if (this.captureRequested && !this.sessionLifecycle && !this.continuous && api.session == null)
+          this.startAudioCapture(connectOptions.stream);
+        else this.suppliedStream = connectOptions.stream;
+      }
+      if (!current()) return;
+      this.reducer = new RealtimeEventReducer(this.maxEvents);
+      this.currentResponseItemId = null;
+      this.toolCallsInResponse.clear();
+      this.submittedToolOutputs.clear();
+      this.responseToolCallsClosed = false;
+      if (this.sessionLifecycle)
+        this.applyState({ ...this.state, session: createSessionState() });
+      if (!current()) return;
+      this.commands = new RealtimeCommandTracker((event) => {
+        const writable = () => current() && !attempt.transportClosing && attempt.cause == null && (!attempt.closing || event.type === "session-close");
+        if (!writable()) throw new Error("Realtime connection is closed");
+        return this.sendTransport(event, writable);
       });
-      if (!response.ok) {
-        throw new Error(`Failed to fetch realtime setup: ${response.status}`);
-      }
-      const setupData = await response.json();
-      const { token, url, tools: toolDefinitions } = setupData;
-      const config = {
-        ...this.sessionConfig,
-        tools: toolDefinitions
+      attempt.timer("startup", (_b25 = this.options.startupTimeoutMs) != null ? _b25 : 3e4, () => {
+        if (current())
+          this.fail(new Error("Realtime session startup timed out"));
+      });
+      const callbacks = {
+        model,
+        onEvent: async (event) => {
+          var _a26, _b26, _c2;
+          if (!current()) return;
+          try {
+            await this.handleServerEvent(event, attempt);
+          } catch (error) {
+            if (current())
+              this.fail(
+                error,
+                (_c2 = (_b26 = (_a26 = this.rtc) != null ? _a26 : this.pcm) != null ? _b26 : this.transport) == null ? void 0 : _c2.finish()
+              );
+          }
+        },
+        onError: (error) => {
+          if (current()) void this.reportError(error, attempt);
+        },
+        onFatalError: (error, drain) => {
+          if (current()) this.fail(error, drain);
+        },
+        onClosing: () => {
+          if (!current()) return;
+          attempt.beginClose();
+          attempt.transportClosing = true;
+          attempt.clearTimer("startup");
+          attempt.clearTimer("close");
+          this.stopAudioCapture();
+          if (!current()) return;
+          this.applyState({
+            ...this.state,
+            status: attempt.cause == null ? "closing" : "error"
+          });
+        },
+        onClose: (error) => {
+          var _a26, _b26;
+          if (!current()) return;
+          const finalizationConfirmed = ((_a26 = model.capabilities) == null ? void 0 : _a26.finalization) === "session-close" && ((_b26 = this.state.session) == null ? void 0 : _b26.finalization) === "confirmed";
+          if (error != null && !finalizationConfirmed) this.fail(error);
+          else if (!attempt.ready && !finalizationConfirmed)
+            this.fail(
+              new Error("Realtime connection closed before becoming ready")
+            );
+          else this.disconnect();
+        },
+        onCapturing: (isCapturing) => {
+          if (current()) this.applyState({ ...this.state, isCapturing });
+        },
+        onPlaying: (isPlaying) => {
+          if (current()) this.applyState({ ...this.state, isPlaying });
+        }
       };
-      this.audio.ensurePlaybackContext();
-      this.transport.connect({
-        token,
-        url,
-        onOpen: () => {
-          this.sendEvent({
-            type: "session-update",
-            config
+      if (api.session != null) {
+        this.rtc = new BrowserRealtimeWebRTC({
+          ...callbacks,
+          disconnectTimeoutMs: this.options.rtcDisconnectTimeoutMs
+        });
+        await this.rtc.connect({
+          api: api.session,
+          sessionConfig,
+          stream: connectOptions == null ? void 0 : connectOptions.stream,
+          capture: connectOptions == null ? void 0 : connectOptions.capture,
+          timeoutMs: (_c = this.options.startupTimeoutMs) != null ? _c : 3e4
+        });
+      } else if (api.websocket != null && ((_d = model.capabilities) == null ? void 0 : _d.conversation) === "continuous") {
+        this.pcm = new BrowserRealtimeLiveWebSocket({
+          ...callbacks,
+          sessionConfig,
+          sampleRate: this.options.sampleRate,
+          maxPlaybackBufferSeconds: this.options.maxPlaybackBufferSeconds
+        });
+        this.pcm.connect({
+          url: api.websocket,
+          protocols: api.protocols,
+          stream: connectOptions == null ? void 0 : connectOptions.stream,
+          capture: connectOptions == null ? void 0 : connectOptions.capture
+        });
+      } else {
+        this.ensureAudio();
+        let config = sessionConfig != null ? sessionConfig : {};
+        let token;
+        let url = api.websocket;
+        if (api.token != null) {
+          const response = await fetch(api.token, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ sessionConfig }),
+            signal: attempt.abort.signal
+          });
+          if (!current()) return;
+          if (!response.ok)
+            throw new Error(
+              `Failed to fetch realtime setup: ${response.status}`
+            );
+          const payload = await response.json().catch(() => {
+            throw new Error("Invalid realtime setup response");
           });
+          if (!current() || attempt.closing) return;
+          const setup = validateRealtimeSetup(payload);
+          token = setup.token;
+          url = setup.url;
+          config = {
+            ...sessionConfig,
+            ...setup.tools == null ? {} : { tools: setup.tools }
+          };
         }
-      });
+        if (url == null) throw new Error("Realtime WebSocket URL is missing");
+        if (api.token != null && token == null)
+          throw new Error("Realtime client-secret connection requires a token");
+        this.ensureAudio().ensurePlaybackContext();
+        if (!current()) return;
+        this.transport = new BrowserRealtimeTransport({
+          ...callbacks,
+          onServerEvent: callbacks.onEvent
+        });
+        this.transport.connect({
+          ...token != null ? { mode: "client-secret", token } : { mode: "relay", protocols: api.protocols },
+          url,
+          onOpen: () => {
+            var _a26, _b26;
+            const writable = () => current() && !attempt.closing && attempt.cause == null;
+            if (!writable()) return;
+            return this.sendTransport(
+              {
+                type: (_b26 = (_a26 = model.capabilities) == null ? void 0 : _a26.startup) != null ? _b26 : "session-update",
+                config
+              },
+              writable
+            );
+          }
+        });
+      }
     } catch (error) {
-      this.applyState(this.reducer.setStatus(this.state, "error"));
-      (_a25 = this.onError) == null ? void 0 : _a25.call(
-        this,
-        error instanceof Error ? error : new Error(`Connection failed: ${String(error)}`)
-      );
+      if (current()) this.fail(error);
+    }
+  }
+  fail(error, drain) {
+    const attempt = this.attempt;
+    if (attempt == null || !attempt.active || attempt.cause != null) return;
+    attempt.cause = error instanceof Error ? error : new Error(String(error));
+    if (drain != null) attempt.beginClose();
+    this.applyState({ ...this.state, status: "error" });
+    if (this.attempt !== attempt || !attempt.active) return;
+    this.stopAudioCapture();
+    if (this.attempt !== attempt || !attempt.active) return;
+    if (drain == null) this.disconnect();
+    else void this.drainAttempt(attempt, drain);
+    void this.reportError(attempt.cause, attempt);
+  }
+  async drainAttempt(attempt, drain) {
+    if (this.attempt === attempt && attempt.active)
+      attempt.timer("drain", 1e3, () => this.finishAttempt(attempt));
+    try {
+      await drain;
+    } catch (e) {
+    }
+    this.finishAttempt(attempt);
+  }
+  finishAttempt(attempt) {
+    if (this.attempt !== attempt || !attempt.active) return;
+    try {
+      this.disconnect();
+    } catch (error) {
+      void this.reportError(error, attempt);
     }
   }
+  closeFailed(attempt, error) {
+    var _a25, _b25;
+    if (this.attempt !== attempt || !attempt.active || attempt.transportClosing)
+      return;
+    attempt.clearTimer("close");
+    const transport = (_b25 = (_a25 = this.rtc) != null ? _a25 : this.pcm) != null ? _b25 : this.transport;
+    void this.drainAttempt(attempt, transport == null ? void 0 : transport.finish());
+    void this.reportError(error, attempt);
+  }
   disconnect() {
-    this.transport.disconnect();
-    this.applyState(this.reducer.setStatus(this.state, "disconnected"));
+    const attempt = this.attempt;
+    this.captureGeneration++;
+    this.captureRequested = false;
+    this.suppliedStream = void 0;
+    const transport = this.transport;
+    const audio = this.audio;
+    const pcm = this.pcm;
+    const rtc = this.rtc;
+    this.transport = void 0;
+    this.audio = void 0;
+    this.pcm = void 0;
+    this.rtc = void 0;
+    this.commands = void 0;
+    attempt == null ? void 0 : attempt.retire();
+    transport == null ? void 0 : transport.dispose();
+    audio == null ? void 0 : audio.dispose();
+    pcm == null ? void 0 : pcm.dispose();
+    rtc == null ? void 0 : rtc.dispose();
+    if (this.attempt !== attempt) return;
+    const session = this.state.session;
+    this.applyState({
+      ...this.state,
+      status: (attempt == null ? void 0 : attempt.cause) != null ? "error" : "disconnected",
+      isCapturing: false,
+      isPlaying: false,
+      ...session != null ? {
+        session: session.finalization === "confirmed" ? session : { ...session, finalization: "unconfirmed" }
+      } : {}
+    });
+  }
+  /** Wait for final usage when the model supports a session-close acknowledgement. */
+  close(options) {
+    var _a25, _b25, _c, _d;
+    const attempt = this.attempt;
+    if ((attempt == null ? void 0 : attempt.closePromise) != null) return attempt.closePromise;
+    if (this.state.status !== "connected" || ((_a25 = this.options.model.capabilities) == null ? void 0 : _a25.finalization) !== "session-close" || attempt == null) {
+      this.disconnect();
+      return Promise.resolve();
+    }
+    if ((options == null ? void 0 : options.eventId) != null) (_b25 = this.commands) == null ? void 0 : _b25.validateId(options.eventId);
+    const promise = attempt.beginClose();
+    this.applyState({ ...this.state, status: "closing" });
+    if (this.attempt !== attempt || !attempt.active || attempt.transportClosing)
+      return promise;
+    this.stopAudioCapture();
+    if (this.attempt !== attempt || !attempt.active || attempt.transportClosing)
+      return promise;
+    attempt.timer(
+      "close",
+      (_c = this.options.closeTimeoutMs) != null ? _c : 15e3,
+      () => this.finishAttempt(attempt)
+    );
+    const failed = (error) => this.closeFailed(attempt, error);
+    try {
+      void ((_d = this.commands) == null ? void 0 : _d.send({ type: "session-close", eventId: options == null ? void 0 : options.eventId }).catch(failed));
+    } catch (error) {
+      failed(error);
+    }
+    return promise;
+  }
+  sendTransport(event, guard, automaticAudio = false) {
+    var _a25, _b25;
+    const transport = (_b25 = (_a25 = this.rtc) != null ? _a25 : this.pcm) != null ? _b25 : this.transport;
+    if (transport == null) throw new Error("Realtime connection is not open");
+    if (transport === this.transport)
+      return this.transport.sendEvent(event, guard, automaticAudio);
+    return transport.sendEvent(event, guard);
   }
-  // ── Sending events ─────────────────────────────────────────────────
   sendEvent(event) {
-    this.transport.sendEvent(event);
+    var _a25, _b25, _c, _d;
+    if (this.state.status === "error" || this.state.status === "closing" || ((_a25 = this.attempt) == null ? void 0 : _a25.closing) || !((_b25 = this.attempt) == null ? void 0 : _b25.active))
+      throw new Error("Realtime session is not accepting submissions");
+    if (this.sessionLifecycle && this.state.status !== "connected")
+      throw new Error("Realtime session is not accepting submissions");
+    if (this.rtc != null && event.type === "input-audio-append" || (this.continuous || this.rtc != null) && (event.type === "input-audio-commit" || event.type === "input-audio-clear"))
+      throw new UnsupportedFunctionalityError6({
+        functionality: "JSON audio commands unsupported for this session transport"
+      });
+    if (event.type === "session-close")
+      return this.close({ eventId: event.eventId });
+    if (event.type === "session-start" && this.sessionLifecycle)
+      throw new Error("Realtime session has already started");
+    if (!this.sessionLifecycle && this.state.session == null) {
+      const attempt = this.attempt;
+      return this.sendTransport(
+        event,
+        () => this.attempt === attempt && attempt.active && !attempt.closing && attempt.cause == null
+      );
+    }
+    return (_d = (_c = this.commands) == null ? void 0 : _c.send(event)) != null ? _d : this.sendTransport(event);
   }
   sendTextMessage(text2) {
+    if (this.continuous)
+      throw new UnsupportedFunctionalityError6({
+        functionality: "sendTextMessage for continuous sessions; client-delegation text is application-owned, use context-append for context"
+      });
     this.sendEvent({
       type: "conversation-item-create",
       item: { type: "text-message", role: "user", text: text2 }
@@ -17715,8 +19258,12 @@ var AbstractRealtimeSession = class {
     this.sendEvent({ type: "response-create" });
     this.applyState(this.reducer.addUserTextMessage(this.state, text2));
   }
-  sendAudio(base64Audio) {
-    this.sendEvent({ type: "input-audio-append", audio: base64Audio });
+  sendAudio(audio) {
+    const attempt = this.attempt;
+    void this.sendEvent({ type: "input-audio-append", audio }).catch((error) => {
+      if ((attempt == null ? void 0 : attempt.active) && this.attempt === attempt)
+        void this.reportError(error, attempt);
+    });
   }
   commitAudio() {
     this.sendEvent({ type: "input-audio-commit" });
@@ -17733,161 +19280,301 @@ var AbstractRealtimeSession = class {
   cancelResponse() {
     this.sendEvent({ type: "response-cancel" });
   }
-  // ── Tool output ───────────────────────────────────────────────────
+  sendAutomaticAudio(audio) {
+    var _a25;
+    if (this.state.status !== "connected" || !((_a25 = this.attempt) == null ? void 0 : _a25.active) || this.attempt.closing)
+      return;
+    const attempt = this.attempt;
+    const failed = (error) => {
+      if ((attempt == null ? void 0 : attempt.active) && this.attempt === attempt && !attempt.closing)
+        this.fail(error);
+    };
+    try {
+      void this.sendTransport(
+        { type: "input-audio-append", audio },
+        () => this.attempt === attempt && attempt.active && !attempt.closing,
+        true
+      ).catch(failed);
+    } catch (error) {
+      failed(error);
+    }
+  }
   addToolOutput(callId, result) {
+    if (this.continuous)
+      throw new UnsupportedFunctionalityError6({
+        functionality: "addToolOutput for continuous sessions; client delegation is application-owned"
+      });
+    const attempt = this.attempt;
+    if (!(attempt == null ? void 0 : attempt.active) || attempt.closing || attempt.cause != null)
+      throw new Error("Realtime session is not accepting submissions");
     const { state, output } = this.reducer.addToolOutput(
       this.state,
       callId,
       result
     );
     this.applyState(state);
+    if (this.attempt !== attempt || !(attempt == null ? void 0 : attempt.active)) return;
     this.sendEvent({
       type: "conversation-item-create",
-      item: {
-        type: "function-call-output",
-        callId: output.callId,
-        name: output.name,
-        output: output.output
-      }
+      item: { type: "function-call-output", ...output }
     });
     this.submittedToolOutputs.add(callId);
     this.maybeRequestToolResponse();
   }
-  /**
-   * Requests a single response once the tool-bearing response has finished
-   * delivering its tool calls and every one of them has an output. Requesting a
-   * response after each individual output can cause the model to continue
-   * without the full tool context on multi-tool turns.
-   */
   maybeRequestToolResponse() {
-    if (!this.responseToolCallsClosed) return;
-    if (this.toolCallsInResponse.size === 0) return;
-    for (const callId of this.toolCallsInResponse) {
-      if (!this.submittedToolOutputs.has(callId)) return;
-    }
+    var _a25;
+    if (this.state.status !== "connected" || ((_a25 = this.attempt) == null ? void 0 : _a25.closing) || !this.responseToolCallsClosed || this.toolCallsInResponse.size === 0 || [...this.toolCallsInResponse].some(
+      (id) => !this.submittedToolOutputs.has(id)
+    ))
+      return;
     this.sendEvent({ type: "response-create" });
     this.toolCallsInResponse.clear();
     this.submittedToolOutputs.clear();
     this.responseToolCallsClosed = false;
   }
-  // ── Audio capture ──────────────────────────────────────────────────
   startAudioCapture(stream) {
-    this.audio.startCapture(stream);
+    var _a25;
+    const legacy = !this.sessionLifecycle && !this.continuous && this.options.api.session == null;
+    if (!legacy && this.state.status !== "connected")
+      throw new Error("Realtime session is not accepting capture");
+    if (((_a25 = this.attempt) == null ? void 0 : _a25.active) && (this.attempt.closing || this.attempt.cause != null))
+      throw new Error("Realtime session is not accepting capture");
+    this.suppliedStream = stream;
+    if (legacy) {
+      this.captureGeneration++;
+      this.captureRequested = true;
+      this.ensureAudio().startCapture(stream);
+      return;
+    }
+    const attempt = this.attempt;
+    void this.resumeAudioCapture().catch((error) => {
+      if (attempt == null ? void 0 : attempt.active) void this.reportError(error, attempt);
+    });
+  }
+  async resumeAudioCapture() {
+    const accepting = () => {
+      var _a25, _b25;
+      return !((_a25 = this.attempt) == null ? void 0 : _a25.closing) && ((_b25 = this.attempt) == null ? void 0 : _b25.cause) == null && (this.state.status === "connected" || !this.sessionLifecycle && this.state.status === "connecting");
+    };
+    if (!accepting())
+      throw new Error("Realtime session is not accepting capture");
+    this.captureRequested = true;
+    if (this.rtc != null) return this.rtc.startCapture(this.suppliedStream);
+    if (this.pcm != null) return this.pcm.resumeCapture(this.suppliedStream);
+    const audio = this.audio;
+    if (audio == null)
+      throw new Error("Realtime capture transport is not ready");
+    const captureGeneration = ++this.captureGeneration;
+    const attempt = this.attempt;
+    const supplied = this.suppliedStream;
+    const stream = supplied != null ? supplied : await navigator.mediaDevices.getUserMedia({ audio: true });
+    if (!(attempt == null ? void 0 : attempt.active) || this.attempt !== attempt || this.audio !== audio || !accepting() || captureGeneration !== this.captureGeneration) {
+      if (supplied == null) stream.getTracks().forEach((track) => track.stop());
+      return;
+    }
+    audio.startCapture(stream, {
+      ownsStream: supplied == null || !this.sessionLifecycle || this.options.api.token != null
+    });
   }
   stopAudioCapture() {
-    this.audio.stopCapture();
+    this.captureGeneration++;
+    this.captureRequested = false;
+    if (this.audio != null && (!this.sessionLifecycle || this.options.api.token != null))
+      this.suppliedStream = void 0;
+    const pcm = this.pcm;
+    const audio = this.audio;
+    const rtc = this.rtc;
+    const attempt = this.attempt;
+    if (rtc != null)
+      void rtc.stopCapture().catch((error) => {
+        if ((attempt == null ? void 0 : attempt.active) && this.attempt === attempt)
+          void this.reportError(error, attempt);
+      });
+    pcm == null ? void 0 : pcm.stopCapture();
+    audio == null ? void 0 : audio.stopCapture();
   }
-  // ── Playback ───────────────────────────────────────────────────────
   stopPlayback() {
-    this.audio.stopPlayback();
+    var _a25, _b25, _c;
+    (_c = (_b25 = (_a25 = this.rtc) != null ? _a25 : this.pcm) != null ? _b25 : this.audio) == null ? void 0 : _c.stopPlayback();
+  }
+  async resumePlayback() {
+    var _a25, _b25, _c;
+    await ((_c = (_b25 = (_a25 = this.rtc) != null ? _a25 : this.pcm) != null ? _b25 : this.audio) == null ? void 0 : _c.resumePlayback());
   }
-  // ── Cleanup ────────────────────────────────────────────────────────
   dispose() {
-    this.transport.dispose();
-    this.audio.dispose();
-    this.applyState(
-      this.reducer.setStatus(
-        this.reducer.setPlaying(
-          this.reducer.setCapturing(this.state, false),
-          false
-        ),
-        "disconnected"
-      )
-    );
+    this.disconnect();
+  }
+  ensureAudio() {
+    var _a25, _b25, _c, _d, _e, _f;
+    if (this.audio != null) return this.audio;
+    const { sessionConfig, sampleRate } = this.options;
+    const audio = new BrowserRealtimeAudio({
+      captureSampleRate: (_c = (_b25 = (_a25 = sessionConfig == null ? void 0 : sessionConfig.inputAudioFormat) == null ? void 0 : _a25.rate) != null ? _b25 : sampleRate) != null ? _c : 24e3,
+      playbackSampleRate: (_f = (_e = (_d = sessionConfig == null ? void 0 : sessionConfig.outputAudioFormat) == null ? void 0 : _d.rate) != null ? _e : sampleRate) != null ? _f : 24e3,
+      onAudio: (value) => {
+        if (this.audio === audio) this.sendAutomaticAudio(value);
+      },
+      onError: (error) => {
+        if (this.audio !== audio) return;
+        void this.reportError(error, this.attempt);
+      },
+      onCapturingChange: (isCapturing) => {
+        if (this.audio === audio)
+          this.applyState({ ...this.state, isCapturing });
+      },
+      onPlayingChange: (isPlaying) => {
+        if (this.audio === audio) this.applyState({ ...this.state, isPlaying });
+      }
+    });
+    this.audio = audio;
+    return audio;
   }
-  // ── Private helpers ────────────────────────────────────────────────
   applyState(nextState) {
-    const previousState = this.state;
+    const publication = ++this.publication;
+    const previous = this.state;
     this.state = nextState;
-    if (previousState.status !== nextState.status) {
-      this.setState("status", nextState.status);
-    }
-    if (previousState.messages !== nextState.messages) {
-      this.setState("messages", nextState.messages);
-    }
-    if (previousState.events !== nextState.events) {
-      this.setState("events", nextState.events);
-    }
-    if (previousState.isCapturing !== nextState.isCapturing) {
-      this.setState("isCapturing", nextState.isCapturing);
-    }
-    if (previousState.isPlaying !== nextState.isPlaying) {
-      this.setState("isPlaying", nextState.isPlaying);
-    }
-  }
-  async executeToolCall({
-    name: name25,
-    args,
-    callId
-  }) {
-    var _a25, _b25;
-    if (this.onToolCall == null) {
-      (_a25 = this.onError) == null ? void 0 : _a25.call(this, new Error(`No handler provided for tool "${name25}"`));
+    const update = (key) => {
+      if (publication === this.publication && previous[key] !== nextState[key])
+        this.setState(key, nextState[key]);
+    };
+    update("status");
+    update("messages");
+    update("events");
+    update("isCapturing");
+    update("isPlaying");
+    update("session");
+  }
+  async executeTool(callId, name25, args, attempt) {
+    if (this.continuous || this.attempt !== attempt || !attempt.active || attempt.closing || attempt.cause != null)
       return;
-    }
     try {
+      if (this.onToolCall == null) {
+        void this.reportError(
+          new Error(`No handler provided for tool "${name25}"`),
+          attempt
+        );
+        return;
+      }
       const result = await this.onToolCall({
         toolCall: { toolCallId: callId, toolName: name25, args }
       });
-      if (result !== void 0) {
+      if (result !== void 0 && this.attempt === attempt && (attempt == null ? void 0 : attempt.active) && this.state.status === "connected")
         this.addToolOutput(callId, result);
-      }
     } catch (error) {
-      (_b25 = this.onError) == null ? void 0 : _b25.call(
-        this,
-        error instanceof Error ? error : new Error(`Client tool execution failed: ${String(error)}`)
-      );
+      if (attempt.active) void this.reportError(error, attempt);
     }
   }
-  async handleServerEvent(event) {
-    var _a25;
+  async handleServerEvent(event, attempt) {
+    var _a25, _b25, _c, _d, _e, _f;
+    const current = () => this.attempt === attempt && attempt.active;
+    if (!current()) return;
+    if (event.type === "session-started" && event.delegationMode === "provider")
+      throw new UnsupportedFunctionalityError6({
+        functionality: "Provider delegation mode; this realtime runtime supports client delegation only"
+      });
+    if (this.continuous && event.type === "audio-delta")
+      throw new UnsupportedFunctionalityError6({
+        functionality: "Turn-based audio-delta in a continuous PCM session; use audio-chunk"
+      });
+    const command = (_a25 = this.commands) == null ? void 0 : _a25.receive(event);
     const result = await this.reducer.reduceServerEvent(this.state, event);
-    this.applyState(result.state);
-    (_a25 = this.onEvent) == null ? void 0 : _a25.call(this, event);
+    if (!current()) return;
+    const session = (_b25 = this.state.session) != null ? _b25 : event.type === "session-started" ? createSessionState() : void 0;
+    this.applyState({
+      ...result.state,
+      status: this.state.status,
+      ...session == null ? {} : {
+        session: reduceSessionState(
+          session,
+          event,
+          this.maxEvents,
+          command == null ? void 0 : command.muted
+        )
+      }
+    });
+    if (!current()) return;
     for (const effect of result.effects) {
-      this.handleReducerEffect(effect);
+      this.handleReducerEffect(effect, attempt);
+      if (!current()) return;
     }
+    if (event.type === "audio-chunk")
+      (_d = (_c = this.pcm) != null ? _c : this.audio) == null ? void 0 : _d.playAudio(event.delta);
+    if (!current()) return;
     if (event.type === "response-done" && this.toolCallsInResponse.size > 0) {
       this.responseToolCallsClosed = true;
       this.maybeRequestToolResponse();
     }
+    if (!current()) return;
+    if (event.type === "session-closed" && session != null) {
+      this.disconnect();
+      this.notifyEvent(event, attempt, true);
+      return;
+    }
+    if ((event.type === "session-started" || event.type === "session-created" || event.type === "session-updated") && attempt.active && !attempt.closing && attempt.cause == null) {
+      const ready = ((_e = this.options.model.capabilities) == null ? void 0 : _e.startup) === "session-start" ? event.type === "session-started" : event.type !== "session-started";
+      if (ready) {
+        attempt.ready = true;
+        attempt.clearTimer("startup");
+        this.applyState({ ...this.state, status: "connected" });
+        if (!current() || attempt.closing) return;
+        (_f = this.pcm) == null ? void 0 : _f.startCapture();
+      }
+    }
+    if (current()) this.notifyEvent(event, attempt);
   }
-  handleReducerEffect(effect) {
-    var _a25;
+  handleReducerEffect(effect, attempt) {
+    var _a25, _b25, _c, _d;
     switch (effect.type) {
-      case "play-audio": {
+      case "play-audio":
         this.currentResponseItemId = effect.itemId;
-        this.audio.playAudio(effect.delta);
+        (_a25 = this.audio) == null ? void 0 : _a25.playAudio(effect.delta);
         break;
-      }
-      case "speech-started": {
-        if (this.state.isPlaying) {
-          const playedMs = this.audio.getPlaybackOffsetMs();
-          this.audio.stopPlayback();
-          if (this.currentResponseItemId != null) {
+      case "speech-started":
+        if (!this.continuous && this.state.isPlaying) {
+          const playedMs = (_c = (_b25 = this.audio) == null ? void 0 : _b25.getPlaybackOffsetMs()) != null ? _c : 0;
+          const itemId = this.currentResponseItemId;
+          (_d = this.audio) == null ? void 0 : _d.stopPlayback();
+          if (this.attempt !== attempt || !attempt.active) return;
+          if (itemId != null && !attempt.closing && attempt.cause == null)
             this.sendEvent({
               type: "conversation-item-truncate",
-              itemId: this.currentResponseItemId,
+              itemId,
               contentIndex: 0,
               audioEndMs: Math.round(playedMs)
             });
-          }
         }
         break;
-      }
-      case "tool-call": {
+      case "tool-call":
+        if (this.continuous) break;
         this.toolCallsInResponse.add(effect.callId);
-        void this.executeToolCall({
-          name: effect.name,
-          args: effect.args,
-          callId: effect.callId
-        });
+        void this.executeTool(effect.callId, effect.name, effect.args, attempt);
         break;
-      }
-      case "error": {
-        (_a25 = this.onError) == null ? void 0 : _a25.call(this, effect.error);
+      case "error":
+        void this.reportError(effect.error, attempt);
         break;
-      }
+    }
+  }
+  async reportError(error, attempt) {
+    var _a25;
+    if (this.attempt !== attempt) return;
+    try {
+      await ((_a25 = this.onError) == null ? void 0 : _a25.call(
+        this,
+        error instanceof Error ? error : new Error(String(error))
+      ));
+    } catch (e) {
+    }
+  }
+  notifyEvent(event, attempt, terminal = false) {
+    var _a25;
+    if (this.attempt !== attempt || !attempt.active && !terminal) return;
+    const report = (error) => {
+      if (attempt.active || terminal) void this.reportError(error, attempt);
+    };
+    try {
+      void Promise.resolve((_a25 = this.onEvent) == null ? void 0 : _a25.call(this, event)).catch(report);
+    } catch (error) {
+      report(error);
     }
   }
 };
@@ -18544,7 +20231,7 @@ var DefaultTranscriptionResult = class {
 
 // src/transcribe/stream-transcribe.ts
 import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError5
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError7
 } from "@ai-sdk/provider";
 import {
   DelayedPromise as DelayedPromise3,
@@ -18567,7 +20254,7 @@ function streamTranscribe({
   }
   const doStream = (_a25 = resolvedModel.doStream) == null ? void 0 : _a25.bind(resolvedModel);
   if (doStream == null) {
-    throw new UnsupportedFunctionalityError5({
+    throw new UnsupportedFunctionalityError7({
       functionality: "streaming transcription",
       message: `The ${resolvedModel.provider} model "${resolvedModel.modelId}" does not support streaming transcription.` + (typeof model === "string" ? " String model IDs resolve through the global provider (AI Gateway by default). If that provider does not support streaming transcription, pass a provider model instance instead (e.g. openai.transcription('gpt-realtime-whisper')) or upgrade @ai-sdk/gateway to a version with streaming transcription support." : "")
     });
@@ -19143,13 +20830,13 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/ui/convert-file-list-to-file-ui-parts.ts
-import { UnsupportedFunctionalityError as UnsupportedFunctionalityError6 } from "@ai-sdk/provider";
+import { UnsupportedFunctionalityError as UnsupportedFunctionalityError8 } from "@ai-sdk/provider";
 async function convertFileListToFileUIParts(files) {
   if (files == null) {
     return [];
   }
   if (!globalThis.FileList || !(files instanceof globalThis.FileList)) {
-    throw new UnsupportedFunctionalityError6({
+    throw new UnsupportedFunctionalityError8({
       functionality: "FileList",
       message: "FileList is not supported in the current environment"
     });
@@ -19333,8 +21020,8 @@ var DefaultChatTransport = class extends HttpChatTransport {
 // src/ui/chat.ts
 var AbstractChat = class {
   constructor({
-    generateId: generateId4 = generateIdFunc2,
-    id = generateId4(),
+    generateId: generateId5 = generateIdFunc2,
+    id = generateId5(),
     transport = new DefaultChatTransport(),
     messageMetadataSchema,
     dataPartSchemas,
@@ -19546,7 +21233,7 @@ var AbstractChat = class {
     };
     this.id = id;
     this.transport = transport;
-    this.generateId = generateId4;
+    this.generateId = generateId5;
     this.messageMetadataSchema = messageMetadataSchema;
     this.dataPartSchemas = dataPartSchemas;
     this.state = state;
@@ -20132,7 +21819,7 @@ export {
   extractReasoningMiddleware,
   fingerprintTools,
   gateway3 as gateway,
-  generateId3 as generateId,
+  generateId4 as generateId,
   generateImage,
   generateObject,
   generateSpeech,