@opengeni/sdk 0.36.0 → 0.37.0

package/dist/chunk-OB5PGV6N.js

@@ -0,0 +1,1988 @@
+import {
+  OpenGeniApiError
+} from "./chunk-OINSI33U.js";
+
+// src/codex-realtime-v3-wire.ts
+var CODEX_REALTIME_CONTEXT_APPEND_MAX_BYTES = 500;
+var CODEX_REALTIME_V3_MAX_EVENT_BYTES = 1048576;
+var CODEX_REALTIME_V3_MAX_IDENTIFIER_BYTES = 1024;
+var CODEX_REALTIME_V3_MAX_TEXT_BYTES = 131072;
+function parseCodexRealtimeV3Event(payload) {
+  if (utf8ByteLength(payload) > CODEX_REALTIME_V3_MAX_EVENT_BYTES) {
+    return failure("oversized_event", null);
+  }
+  let value;
+  try {
+    value = JSON.parse(payload);
+  } catch {
+    return failure("invalid_json", null);
+  }
+  const event = record(value);
+  const typeField = boundedStringField(event, "type", CODEX_REALTIME_V3_MAX_IDENTIFIER_BYTES);
+  if (typeField.oversized) return failure("oversized_field", null);
+  const type = typeField.value;
+  if (!type) return failure("missing_type", null);
+  const providerEventIdField = firstBoundedStringField(
+    event,
+    ["event_id", "id"],
+    CODEX_REALTIME_V3_MAX_IDENTIFIER_BYTES
+  );
+  if (providerEventIdField.oversized) return failure("oversized_field", type);
+  const providerEventId = providerEventIdField.value ?? null;
+  if (type === "session.started" || type === "session.updated") {
+    const session = record(event.session);
+    const sessionIdField = boundedStringField(
+      session,
+      "id",
+      CODEX_REALTIME_V3_MAX_IDENTIFIER_BYTES
+    );
+    const instructionsField = boundedStringField(
+      session,
+      "instructions",
+      CODEX_REALTIME_V3_MAX_TEXT_BYTES
+    );
+    if (sessionIdField.oversized || instructionsField.oversized) {
+      return failure("oversized_field", type);
+    }
+    const sessionId = sessionIdField.value;
+    if (!sessionId) return failure("invalid_shape", type);
+    return {
+      ok: true,
+      event: {
+        type,
+        providerEventId,
+        sessionId,
+        instructions: instructionsField.value ?? null
+      }
+    };
+  }
+  if (type === "input_transcript.added" || type === "output_transcript.added") {
+    const item = record(event.item);
+    const itemIdField = boundedStringField(item, "id", CODEX_REALTIME_V3_MAX_IDENTIFIER_BYTES);
+    const textField = boundedStringField(item, "text", CODEX_REALTIME_V3_MAX_TEXT_BYTES);
+    if (itemIdField.oversized || textField.oversized) {
+      return failure("oversized_field", type);
+    }
+    const text = textField.value;
+    if (text === void 0) return failure("invalid_shape", type);
+    return {
+      ok: true,
+      event: {
+        type,
+        providerEventId,
+        itemId: itemIdField.value ?? null,
+        text
+      }
+    };
+  }
+  if (type === "output_audio.delta") {
+    const audio = stringField(event, "audio");
+    if (audio === void 0) return failure("invalid_shape", type);
+    return {
+      ok: true,
+      event: {
+        type,
+        providerEventId,
+        audio,
+        startMs: finiteNumberField(event, "start_ms"),
+        endMs: finiteNumberField(event, "end_ms")
+      }
+    };
+  }
+  if (type === "turn.done") {
+    const turn = record(event.turn);
+    const turnIdField = boundedStringField(turn, "id", CODEX_REALTIME_V3_MAX_IDENTIFIER_BYTES);
+    const transcriptField = boundedStringField(
+      turn,
+      "transcript",
+      CODEX_REALTIME_V3_MAX_TEXT_BYTES
+    );
+    if (turnIdField.oversized || transcriptField.oversized) {
+      return failure("oversized_field", type);
+    }
+    const turnId = turnIdField.value;
+    const role = stringField(turn, "role");
+    const transcript = transcriptField.value;
+    if (!turnId || role !== "user" && role !== "assistant" || transcript === void 0) {
+      return failure("invalid_shape", type);
+    }
+    return {
+      ok: true,
+      event: { type, providerEventId, turnId, role, transcript }
+    };
+  }
+  if (type === "delegation.created") {
+    const item = record(event.item);
+    const delegationItemIdField = boundedStringField(
+      item,
+      "id",
+      CODEX_REALTIME_V3_MAX_IDENTIFIER_BYTES
+    );
+    if (delegationItemIdField.oversized) return failure("oversized_field", type);
+    const delegationItemId = delegationItemIdField.value;
+    if (!delegationItemId || stringField(item, "type") !== "delegation" || stringField(item, "target") !== "client" || !Array.isArray(item.content)) {
+      return failure("invalid_shape", type);
+    }
+    const inputParts = [];
+    let inputBytes = 0;
+    for (const rawContent of item.content) {
+      const content = record(rawContent);
+      if (stringField(content, "type") !== "input_text") continue;
+      const textField = boundedStringField(content, "text", CODEX_REALTIME_V3_MAX_TEXT_BYTES);
+      if (textField.oversized) return failure("oversized_field", type);
+      const text = textField.value ?? "";
+      inputBytes += utf8ByteLength(text);
+      if (inputBytes > CODEX_REALTIME_V3_MAX_TEXT_BYTES) {
+        return failure("oversized_field", type);
+      }
+      inputParts.push(text);
+    }
+    const inputTranscript = inputParts.join("");
+    return {
+      ok: true,
+      event: {
+        type,
+        providerEventId,
+        delegationItemId,
+        inputTranscript,
+        offsetMs: finiteNumberField(event, "offset_ms")
+      }
+    };
+  }
+  if (type === "error") {
+    const nested = record(event.error);
+    const message = stringField(event, "message") ?? stringField(nested, "message") ?? (event.error === void 0 ? void 0 : JSON.stringify(event.error));
+    if (message === void 0) return failure("invalid_shape", type);
+    if (utf8ByteLength(message) > CODEX_REALTIME_V3_MAX_TEXT_BYTES) {
+      return failure("oversized_field", type);
+    }
+    return { ok: true, event: { type, providerEventId, message } };
+  }
+  return failure("unsupported_type", type);
+}
+function encodeCodexRealtimeV3DelegationContextAppend(input) {
+  return contextAppendChunks(input.text).map((text) => ({
+    type: "delegation.context.append",
+    delegation_item_id: input.delegationItemId,
+    ...input.channel ? { channel: input.channel } : {},
+    content: [{ type: "input_text", text }]
+  }));
+}
+function encodeCodexRealtimeV3SessionContextAppend(input) {
+  return contextAppendChunks(input.text).map((text) => ({
+    type: "session.context.append",
+    ...input.channel ? { channel: input.channel } : {},
+    content: [{ type: "input_text", text }]
+  }));
+}
+function contextAppendChunks(text) {
+  if (utf8ByteLength(text) <= CODEX_REALTIME_CONTEXT_APPEND_MAX_BYTES) return [text];
+  const chunks = [];
+  let chunk = "";
+  let bytes = 0;
+  for (const character of text) {
+    const characterBytes = utf8ByteLength(character);
+    if (bytes + characterBytes > CODEX_REALTIME_CONTEXT_APPEND_MAX_BYTES && chunk) {
+      chunks.push(chunk);
+      chunk = "";
+      bytes = 0;
+    }
+    chunk += character;
+    bytes += characterBytes;
+  }
+  if (chunk || text.length === 0) chunks.push(chunk);
+  return chunks;
+}
+function utf8ByteLength(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+function failure(reason, eventType) {
+  return { ok: false, reason, eventType };
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringField(value, key) {
+  return typeof value[key] === "string" ? value[key] : void 0;
+}
+function boundedStringField(value, key, maxBytes) {
+  const candidate = stringField(value, key);
+  return {
+    value: candidate,
+    oversized: candidate !== void 0 && utf8ByteLength(candidate) > maxBytes
+  };
+}
+function firstBoundedStringField(value, keys, maxBytes) {
+  for (const key of keys) {
+    if (typeof value[key] === "string") return boundedStringField(value, key, maxBytes);
+  }
+  return { value: void 0, oversized: false };
+}
+function finiteNumberField(value, key) {
+  const candidate = value[key];
+  return typeof candidate === "number" && Number.isFinite(candidate) ? candidate : null;
+}
+
+// src/codex-realtime-v3.ts
+var CODEX_REALTIME_V3_SYNC_MAX_ENTRIES = 64;
+var CODEX_REALTIME_V3_PENDING_MAX_ENTRIES = 256;
+var CODEX_REALTIME_V3_PENDING_MAX_BYTES = 16 * 1024 * 1024;
+var REALTIME_DELEGATION_TRANSCRIPT_MAX_BYTES = 65536;
+var REALTIME_DELEGATION_INPUT_MAX_BYTES = 65536;
+function createCodexRealtimeV3Bridge(options) {
+  let closed = false;
+  let sealed = false;
+  let listening = false;
+  let speaking = false;
+  let activeDelegationId = null;
+  let lastError = null;
+  let ignoredEventCount = 0;
+  let lastIgnoredEventType = null;
+  let fatal = null;
+  let providerStarted;
+  let providerStartedAccepted = false;
+  let clientAckThroughSequence = null;
+  let pendingInbound = [];
+  let pendingInboundCount = 0;
+  let pendingInboundBytes = 0;
+  let flushing = null;
+  let flushRequestedWhileRunning = false;
+  let forceSync = false;
+  const clientReceivedSequences = /* @__PURE__ */ new Set();
+  const sentSequences = /* @__PURE__ */ new Set();
+  const finalizedTurnIds = /* @__PURE__ */ new Set();
+  let transcriptSinceDelegation = [];
+  let pendingDelegationUserTranscript = null;
+  const randomUUID = options.randomUUID ?? defaultRandomUUID;
+  const snapshot = () => ({
+    connectionId: options.connectionId,
+    connectionEpoch: options.connectionEpoch,
+    startupFenceSequence: options.startupFenceSequence,
+    modeVersion: options.modeVersion,
+    speaking,
+    activeDelegationId,
+    lastError,
+    ignoredEventCount,
+    lastIgnoredEventType,
+    pendingInbound: pendingInboundCount,
+    pendingInboundBytes,
+    clientAckThroughSequence,
+    providerAckSequences: [],
+    providerStarted: providerStartedAccepted,
+    fatal
+  });
+  const publish = () => options.onSnapshot?.(snapshot());
+  const triggerFatal = (message) => {
+    if (closed || fatal) return;
+    fatal = { code: "pending_overflow", message };
+    lastError = message;
+    publish();
+    try {
+      options.onFatal?.({ ...fatal });
+    } catch {
+    }
+  };
+  const enqueue = (entry) => {
+    if (closed || sealed || fatal) return false;
+    const bytes = utf8ByteLength2(JSON.stringify(entry));
+    if (pendingInboundCount + 1 > CODEX_REALTIME_V3_PENDING_MAX_ENTRIES || pendingInboundBytes + bytes > CODEX_REALTIME_V3_PENDING_MAX_BYTES) {
+      triggerFatal("Codex realtime durable event buffer exceeded its hard limit");
+      return false;
+    }
+    pendingInbound.push({ entry, bytes });
+    pendingInboundCount += 1;
+    pendingInboundBytes += bytes;
+    return true;
+  };
+  const hasWork = () => pendingInbound.length > 0 || !providerStartedAccepted && providerStarted !== void 0 || clientAckThroughSequence !== null || forceSync;
+  const runFlush = async () => {
+    while (true) {
+      if (closed || fatal) break;
+      const batch = pendingInbound.splice(0, CODEX_REALTIME_V3_SYNC_MAX_ENTRIES);
+      const startup = providerStartedAccepted ? void 0 : providerStarted;
+      const acknowledgedByClient = clientAckThroughSequence;
+      const poll = forceSync;
+      forceSync = false;
+      flushRequestedWhileRunning = false;
+      if (batch.length === 0 && !startup && acknowledgedByClient === null && !poll) break;
+      let result;
+      try {
+        result = await options.sync({
+          ...options.owner,
+          connectionId: options.connectionId,
+          connectionEpoch: options.connectionEpoch,
+          ...batch.length === 0 ? {} : { entries: batch.map(({ entry }) => entry) },
+          ...startup ? { providerStarted: startup } : {},
+          ...acknowledgedByClient === null ? {} : { clientAckThroughSequence: acknowledgedByClient }
+        });
+      } catch (error) {
+        pendingInbound = [...batch, ...pendingInbound];
+        throw error;
+      }
+      for (const item of batch) {
+        pendingInboundCount -= 1;
+        pendingInboundBytes -= item.bytes;
+      }
+      if (startup && providerStarted === startup) providerStartedAccepted = true;
+      if (acknowledgedByClient !== null && clientAckThroughSequence !== null && clientAckThroughSequence <= acknowledgedByClient) {
+        clientAckThroughSequence = null;
+      }
+      if (closed || fatal) break;
+      for (const entry of result.outbound) {
+        if (entry.clientAckedAt === null && !clientReceivedSequences.has(entry.sequence)) {
+          clientReceivedSequences.add(entry.sequence);
+          clientAckThroughSequence = Math.max(clientAckThroughSequence ?? 0, entry.sequence);
+        }
+      }
+      for (let index = 0; index < result.outbound.length; ) {
+        const entry = result.outbound[index];
+        if (sentSequences.has(entry.sequence)) {
+          index += 1;
+          continue;
+        }
+        if (entry.kind === "delegation_progress" && entry.delegationItemId) {
+          const progress = [];
+          while (index < result.outbound.length) {
+            const candidate = result.outbound[index];
+            if (candidate.kind !== "delegation_progress" || candidate.delegationItemId !== entry.delegationItemId) {
+              break;
+            }
+            if (!sentSequences.has(candidate.sequence)) progress.push(candidate);
+            index += 1;
+          }
+          sendDelegationProgress(options.events, entry.delegationItemId, progress);
+          for (const candidate of progress) sentSequences.add(candidate.sequence);
+          continue;
+        }
+        sendOutbound(options.events, entry);
+        sentSequences.add(entry.sequence);
+        if (entry.kind === "session_update" && entry.payload.source === "human_input" && entry.payload.delivery === "steer") {
+          activeDelegationId = null;
+        }
+        if ((entry.kind === "delegation_result" || entry.kind === "error") && entry.delegationItemId === activeDelegationId) {
+          activeDelegationId = null;
+        }
+        index += 1;
+      }
+      publish();
+    }
+  };
+  const requestFlush = (poll) => {
+    if (closed || fatal) return Promise.resolve();
+    if (poll) forceSync = true;
+    if (flushing) {
+      flushRequestedWhileRunning = true;
+      return flushing;
+    }
+    const task = Promise.resolve().then(runFlush).catch((error) => {
+      lastError = safeError(error);
+      publish();
+      throw error;
+    });
+    flushing = task;
+    void task.then(
+      () => {
+        if (flushing !== task) return;
+        flushing = null;
+        if (!closed && !fatal && (flushRequestedWhileRunning || hasWork())) {
+          flushRequestedWhileRunning = false;
+          void requestFlush(false).catch(() => void 0);
+        }
+      },
+      () => {
+        if (flushing === task) flushing = null;
+      }
+    );
+    return task;
+  };
+  const ingest = (payload) => {
+    if (closed || sealed || fatal) return Promise.resolve();
+    const parsed = parseCodexRealtimeV3Event(payload);
+    if (!parsed.ok) {
+      if (parsed.reason === "unsupported_type") {
+        ignoredEventCount += 1;
+        lastIgnoredEventType = parsed.eventType;
+        publish();
+        return Promise.resolve();
+      }
+      lastError = `Rejected Codex realtime V3 event: ${parsed.reason}`;
+      publish();
+      return Promise.resolve();
+    }
+    const event = parsed.event;
+    let durable = false;
+    if (event.type === "session.started") {
+      if (!providerStartedAccepted && providerStarted === void 0) {
+        providerStarted = {
+          providerSessionId: event.sessionId,
+          providerEventId: event.providerEventId
+        };
+        durable = true;
+      }
+    } else if (event.type === "input_transcript.added" || event.type === "output_transcript.added") {
+    } else if (event.type === "delegation.created") {
+      activeDelegationId = event.delegationItemId;
+      const transcript = delegationTranscript(transcriptSinceDelegation, event.inputTranscript);
+      const coveredTurnIds = transcriptSinceDelegation.map((entry) => entry.turnId);
+      durable = enqueue({
+        operationId: randomUUID(),
+        kind: "delegation_call",
+        providerEventId: event.providerEventId,
+        delegationItemId: event.delegationItemId,
+        text: renderRealtimeDelegationInput(event.inputTranscript, transcript),
+        payload: {
+          offsetMs: event.offsetMs,
+          inputTranscript: event.inputTranscript,
+          transcriptFenceTurnIds: coveredTurnIds
+        }
+      });
+      if (durable) {
+        const alreadyFinalized = transcriptSinceDelegation.some(
+          (entry) => entry.role === "user" && normalizedTranscript(entry.text) === normalizedTranscript(event.inputTranscript)
+        );
+        pendingDelegationUserTranscript = alreadyFinalized ? null : { delegationItemId: event.delegationItemId, text: event.inputTranscript };
+        transcriptSinceDelegation = [];
+      }
+    } else if (event.type === "output_audio.delta") {
+      speaking = true;
+    } else if (event.type === "turn.done") {
+      speaking = false;
+      if (event.transcript.length > 0 && !finalizedTurnIds.has(event.turnId)) {
+        const coveredByDelegationItemId = event.role === "user" && pendingDelegationUserTranscript !== null && normalizedTranscript(event.transcript) === normalizedTranscript(pendingDelegationUserTranscript.text) ? pendingDelegationUserTranscript.delegationItemId : null;
+        durable = enqueue(finalTranscript(randomUUID, event, coveredByDelegationItemId));
+        if (durable) {
+          finalizedTurnIds.add(event.turnId);
+          if (coveredByDelegationItemId) {
+            pendingDelegationUserTranscript = null;
+          } else {
+            transcriptSinceDelegation.push({
+              role: event.role,
+              text: event.transcript,
+              turnId: event.turnId
+            });
+          }
+        }
+      }
+    } else if (event.type === "error") {
+      lastError = event.message;
+      durable = enqueue({
+        operationId: randomUUID(),
+        kind: "error",
+        providerEventId: event.providerEventId,
+        text: event.message
+      });
+    }
+    publish();
+    return durable ? requestFlush(false) : Promise.resolve();
+  };
+  const onMessage = (message) => {
+    if (typeof message.data !== "string") return;
+    void ingest(message.data).catch(() => void 0);
+  };
+  const listen = () => {
+    if (closed || sealed || listening) return;
+    listening = true;
+    options.events.addEventListener("message", onMessage);
+  };
+  if (options.listen !== false) listen();
+  publish();
+  return {
+    snapshot,
+    ingest,
+    flush: () => requestFlush(true),
+    sealAndFlush: async () => {
+      if (closed) return;
+      sealed = true;
+      if (listening) options.events.removeEventListener("message", onMessage);
+      listening = false;
+      await requestFlush(true);
+    },
+    listen,
+    close: () => {
+      if (closed) return;
+      closed = true;
+      if (listening) options.events.removeEventListener("message", onMessage);
+      listening = false;
+    }
+  };
+}
+function finalTranscript(randomUUID, event, coveredByDelegationItemId) {
+  return {
+    operationId: randomUUID(),
+    kind: event.role === "user" ? "user_transcript" : "assistant_transcript",
+    providerEventId: event.providerEventId,
+    text: event.transcript,
+    payload: {
+      turnId: event.turnId,
+      ...coveredByDelegationItemId ? { coveredByDelegationItemId } : {}
+    }
+  };
+}
+function delegationTranscript(entries, inputTranscript) {
+  const selected = [...entries];
+  const normalizedInput = normalizedTranscript(inputTranscript);
+  for (let index = selected.length - 1; index >= 0; index -= 1) {
+    const entry = selected[index];
+    if (entry?.role === "user" && normalizedInput.length > 0 && normalizedTranscript(entry.text) === normalizedInput) {
+      selected.splice(index, 1);
+      break;
+    }
+  }
+  const bounded = [];
+  let bytes = 0;
+  for (let index = selected.length - 1; index >= 0; index -= 1) {
+    const entry = selected[index];
+    const line = `${entry.role}: ${entry.text}`;
+    const lineBytes = utf8ByteLength2(line) + (bounded.length > 0 ? 1 : 0);
+    if (bytes + lineBytes > REALTIME_DELEGATION_TRANSCRIPT_MAX_BYTES) break;
+    bounded.unshift(entry);
+    bytes += lineBytes;
+  }
+  return bounded;
+}
+function renderRealtimeDelegationInput(inputTranscript, transcript) {
+  const input = takeUtf8Head(inputTranscript, REALTIME_DELEGATION_INPUT_MAX_BYTES);
+  const transcriptDelta = transcript.map((entry) => `${entry.role}: ${entry.text}`).join("\n");
+  return [
+    "<realtime_delegation>",
+    `  <input>${escapeXmlText(input)}</input>`,
+    ...transcriptDelta ? [`  <transcript_delta>${escapeXmlText(transcriptDelta)}</transcript_delta>`] : [],
+    "</realtime_delegation>"
+  ].join("\n");
+}
+function normalizedTranscript(value) {
+  return value.trim().replaceAll(/\s+/g, " ");
+}
+function takeUtf8Head(value, maximumBytes) {
+  const bytes = new TextEncoder().encode(value);
+  if (bytes.length <= maximumBytes) return value;
+  let end = maximumBytes;
+  while (end > 0 && (bytes[end] & 192) === 128) end -= 1;
+  return new TextDecoder().decode(bytes.subarray(0, end));
+}
+function escapeXmlText(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function sendOutbound(events, entry) {
+  if (events.readyState !== "open") throw new Error("Codex realtime data channel is not open");
+  const text = entry.text ?? JSON.stringify(entry.payload);
+  const payloadChannel = entry.payload.channel === "speakable" || entry.payload.channel === "commentary" ? entry.payload.channel : entry.payload.channel === null ? void 0 : entry.kind === "session_update" ? "commentary" : void 0;
+  const messages = (entry.kind === "delegation_result" || entry.kind === "error") && entry.delegationItemId ? encodeCodexRealtimeV3DelegationContextAppend({
+    delegationItemId: entry.delegationItemId,
+    text,
+    channel: payloadChannel ?? "speakable"
+  }) : encodeCodexRealtimeV3SessionContextAppend({ text, channel: payloadChannel });
+  for (const message of messages) events.send(JSON.stringify(message));
+}
+function sendDelegationProgress(events, delegationItemId, entries) {
+  if (entries.length === 0) return;
+  if (events.readyState !== "open") throw new Error("Codex realtime data channel is not open");
+  const text = entries.map((entry) => entry.text ?? "").join("");
+  if (text.length === 0) return;
+  for (const message of encodeCodexRealtimeV3DelegationContextAppend({
+    delegationItemId,
+    text,
+    channel: "commentary"
+  })) {
+    events.send(JSON.stringify(message));
+  }
+}
+function utf8ByteLength2(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+function defaultRandomUUID() {
+  if (!globalThis.crypto?.randomUUID) throw new Error("crypto.randomUUID is unavailable");
+  return globalThis.crypto.randomUUID();
+}
+function safeError(error) {
+  return error instanceof Error ? error.message : "Codex realtime bridge failed";
+}
+
+// src/codex-realtime.ts
+var CodexRealtimeMicrophoneError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "CodexRealtimeMicrophoneError";
+  }
+};
+async function startCodexRealtimeWebrtc(options) {
+  throwIfAborted(options.signal);
+  const peerConnection = (options.createPeerConnection ?? defaultPeerConnection)();
+  const events = peerConnection.createDataChannel("oai-events");
+  try {
+    options.onEventsCreated?.(events);
+  } catch (error) {
+    try {
+      events.close();
+    } finally {
+      peerConnection.close();
+    }
+    throw error;
+  }
+  let media = null;
+  let ownsMedia = false;
+  let stopped = false;
+  let remoteStream = null;
+  let remoteAudioActive = options.activateRemoteAudio ?? true;
+  let outputMuted = false;
+  let audibleOutput = "inactive";
+  let audioAttempt = 0;
+  const publishAudibleOutput = (next) => {
+    if (stopped && next !== "inactive") return;
+    audibleOutput = next;
+    options.onAudibleOutputState?.(next);
+  };
+  const playRemoteAudio = async () => {
+    const remoteAudio = options.remoteAudio;
+    const stream = remoteStream;
+    if (stopped || !remoteAudioActive || !remoteAudio || !stream) return false;
+    remoteAudio.autoplay = true;
+    remoteAudio.muted = outputMuted;
+    remoteAudio.srcObject = stream;
+    const attempt = ++audioAttempt;
+    publishAudibleOutput("pending");
+    try {
+      await remoteAudio.play();
+      if (stopped || attempt !== audioAttempt || remoteAudio.srcObject !== stream) return false;
+      publishAudibleOutput("audible");
+      return true;
+    } catch {
+      if (!stopped && attempt === audioAttempt && remoteAudio.srcObject === stream) {
+        publishAudibleOutput("blocked");
+      }
+      return false;
+    }
+  };
+  const onRemoteTrack = (event) => {
+    if (stopped || event.track.kind !== "audio") return;
+    const stream = event.streams[0];
+    if (!stream) return;
+    remoteStream = stream;
+    if (remoteAudioActive) void playRemoteAudio();
+  };
+  if (options.remoteAudio) peerConnection.addEventListener("track", onRemoteTrack);
+  const onConnectionState = () => {
+    if (stopped) return;
+    const peerState = peerConnection.connectionState;
+    const iceState = peerConnection.iceConnectionState;
+    if (peerState === "failed" || iceState === "failed") {
+      options.onConnectionHealth?.("failed");
+    } else if (peerState === "disconnected" || iceState === "disconnected") {
+      options.onConnectionHealth?.("disconnected");
+    } else if (peerState === "closed" || iceState === "closed") {
+      options.onConnectionHealth?.("closed");
+    } else if (peerState === "connected" || iceState === "connected" || iceState === "completed") {
+      options.onConnectionHealth?.("connected");
+    }
+  };
+  const onChannelClose = () => {
+    if (!stopped) options.onConnectionHealth?.("closed");
+  };
+  const onChannelError = () => {
+    if (!stopped) options.onConnectionHealth?.("failed");
+  };
+  peerConnection.addEventListener("connectionstatechange", onConnectionState);
+  peerConnection.addEventListener("iceconnectionstatechange", onConnectionState);
+  events.addEventListener("close", onChannelClose);
+  events.addEventListener("error", onChannelError);
+  let audioTracks = [];
+  const onMicrophoneEnded = () => {
+    if (!stopped) options.onMicrophoneEnded?.();
+  };
+  const stop = () => {
+    if (stopped) return;
+    stopped = true;
+    audioAttempt += 1;
+    options.signal?.removeEventListener("abort", stop);
+    if (options.remoteAudio) peerConnection.removeEventListener("track", onRemoteTrack);
+    peerConnection.removeEventListener("connectionstatechange", onConnectionState);
+    peerConnection.removeEventListener("iceconnectionstatechange", onConnectionState);
+    events.removeEventListener("close", onChannelClose);
+    events.removeEventListener("error", onChannelError);
+    for (const track of audioTracks) track.removeEventListener?.("ended", onMicrophoneEnded);
+    try {
+      events.close();
+    } finally {
+      try {
+        if (ownsMedia) media?.getTracks().forEach((track) => track.stop());
+      } finally {
+        if (options.remoteAudio && options.remoteAudio.srcObject === remoteStream) {
+          options.remoteAudio.pause();
+          options.remoteAudio.srcObject = null;
+        }
+        remoteStream = null;
+        publishAudibleOutput("inactive");
+        peerConnection.close();
+      }
+    }
+  };
+  options.signal?.addEventListener("abort", stop, { once: true });
+  try {
+    const getUserMedia = options.getUserMedia ?? defaultGetUserMedia;
+    if (options.media) {
+      media = options.media;
+    } else {
+      media = await acquireCodexRealtimeMicrophone({
+        getUserMedia,
+        signal: options.signal
+      });
+      ownsMedia = true;
+    }
+    throwIfAborted(options.signal);
+    audioTracks = media.getAudioTracks();
+    if (audioTracks.length === 0) {
+      throw new CodexRealtimeMicrophoneError(
+        "device_not_found",
+        "No microphone audio track is available"
+      );
+    }
+    if (!microphoneTracksHealthy(audioTracks)) {
+      throw new CodexRealtimeMicrophoneError(
+        "track_ended",
+        "The microphone audio track is no longer available"
+      );
+    }
+    for (const track of audioTracks) {
+      track.addEventListener?.("ended", onMicrophoneEnded);
+      peerConnection.addTrack(track, media);
+    }
+    const offer = await peerConnection.createOffer();
+    if (offer.type !== "offer" || !offer.sdp) {
+      throw new Error("Browser did not create a WebRTC SDP offer");
+    }
+    await peerConnection.setLocalDescription(offer);
+    throwIfAborted(options.signal);
+    const localSdp = peerConnection.localDescription?.sdp ?? offer.sdp;
+    const answer = await options.negotiate(
+      {
+        realtimeId: options.realtimeId,
+        operationId: options.operationId,
+        browserInstanceId: options.browserInstanceId,
+        ownerKey: options.ownerKey,
+        expectedVersion: options.expectedVersion,
+        expectedConnectionEpoch: options.expectedConnectionEpoch,
+        rotate: options.rotate,
+        browserActivation: "required",
+        sdp: localSdp,
+        version: "v3",
+        ...options.instructions === void 0 ? {} : { instructions: options.instructions },
+        ...options.voice === void 0 ? {} : { voice: options.voice }
+      },
+      { signal: options.signal }
+    );
+    throwIfAborted(options.signal);
+    if (answer.version !== "v3" || answer.model !== "gpt-live-1-boulder-alpha" || !answer.sdp) {
+      throw new Error("OpenGeni returned an incompatible Codex realtime answer");
+    }
+    await peerConnection.setRemoteDescription({
+      type: "answer",
+      sdp: answer.sdp
+    });
+    throwIfAborted(options.signal);
+    return {
+      peerConnection,
+      events,
+      media,
+      operationId: options.operationId,
+      connectionId: answer.connectionId,
+      connectionEpoch: answer.connectionEpoch,
+      startupFenceSequence: answer.startupFenceSequence,
+      modeVersion: answer.modeVersion,
+      microphoneHealthy: () => microphoneTracksHealthy(audioTracks),
+      audibleOutputState: () => audibleOutput,
+      setOutputMuted: (muted) => {
+        outputMuted = muted;
+        if (options.remoteAudio) options.remoteAudio.muted = muted;
+      },
+      activateRemoteAudio: () => {
+        if (stopped || remoteAudioActive) return;
+        remoteAudioActive = true;
+        if (remoteStream) void playRemoteAudio();
+      },
+      retryAudibleOutput: playRemoteAudio,
+      stop
+    };
+  } catch (error) {
+    stop();
+    throw error;
+  }
+}
+async function acquireCodexRealtimeMicrophone(options = {}) {
+  const getUserMedia = options.getUserMedia ?? defaultGetUserMedia;
+  let media;
+  try {
+    media = await abortableMedia(getUserMedia({ audio: true }), options.signal);
+  } catch (error) {
+    throw microphoneAcquisitionError(error, options.signal);
+  }
+  const tracks = media.getAudioTracks();
+  if (tracks.length === 0) {
+    media.getTracks().forEach((track) => track.stop());
+    throw new CodexRealtimeMicrophoneError(
+      "device_not_found",
+      "No microphone audio track is available"
+    );
+  }
+  if (!microphoneTracksHealthy(tracks)) {
+    media.getTracks().forEach((track) => track.stop());
+    throw new CodexRealtimeMicrophoneError(
+      "track_ended",
+      "The microphone audio track is no longer available"
+    );
+  }
+  return media;
+}
+function codexRealtimeMicrophoneHealthy(media) {
+  return media !== null && microphoneTracksHealthy(media.getAudioTracks());
+}
+function microphoneTracksHealthy(tracks) {
+  return tracks.length > 0 && tracks.every((track) => track.readyState !== "ended");
+}
+function microphoneAcquisitionError(error, signal) {
+  if (signal?.aborted) {
+    return signal.reason instanceof Error ? signal.reason : new DOMException("Aborted", "AbortError");
+  }
+  const name = error instanceof Error ? error.name : "";
+  if (name === "NotAllowedError" || name === "SecurityError") {
+    return new CodexRealtimeMicrophoneError(
+      "permission_denied",
+      "Microphone permission was denied"
+    );
+  }
+  if (name === "NotFoundError" || name === "DevicesNotFoundError") {
+    return new CodexRealtimeMicrophoneError("device_not_found", "No microphone device was found");
+  }
+  if (name === "NotReadableError" || name === "TrackStartError" || name === "AbortError") {
+    return new CodexRealtimeMicrophoneError(
+      "device_unavailable",
+      "The microphone device is unavailable"
+    );
+  }
+  return new CodexRealtimeMicrophoneError(
+    "acquisition_failed",
+    "Microphone capture could not be started"
+  );
+}
+function defaultPeerConnection() {
+  if (typeof RTCPeerConnection === "undefined") {
+    throw new Error("WebRTC is not available in this environment");
+  }
+  return new RTCPeerConnection();
+}
+async function defaultGetUserMedia(constraints) {
+  if (typeof navigator === "undefined" || !navigator.mediaDevices?.getUserMedia) {
+    throw new Error("Microphone capture is not available in this environment");
+  }
+  return await navigator.mediaDevices.getUserMedia(constraints);
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw signal.reason ?? new DOMException("Aborted", "AbortError");
+  }
+}
+async function abortableMedia(pending, signal) {
+  if (!signal) return await pending;
+  throwIfAborted(signal);
+  let rejectAbort;
+  const aborted = new Promise((_resolve, reject) => {
+    rejectAbort = reject;
+  });
+  const onAbort = () => {
+    rejectAbort?.(signal.reason ?? new DOMException("Aborted", "AbortError"));
+  };
+  signal.addEventListener("abort", onAbort, { once: true });
+  void pending.then(
+    (lateMedia) => {
+      if (signal.aborted) lateMedia.getTracks().forEach((track) => track.stop());
+    },
+    () => void 0
+  );
+  try {
+    return await Promise.race([pending, aborted]);
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+  }
+}
+
+// src/codex-realtime-lifecycle.ts
+function projectSessionRealtimeLifecycle(events) {
+  let projected = null;
+  for (const event of [...events].sort((left, right) => left.sequence - right.sequence)) {
+    const payload = recordValue(event.payload);
+    if (event.type === "session.realtime.started") {
+      const realtimeId = stringValue(payload?.realtimeId);
+      const operationId = stringValue(payload?.operationId);
+      const version = positiveInteger(payload?.version);
+      const connectionEpoch = positiveInteger(payload?.connectionEpoch);
+      const leaseExpiresAt = stringValue(payload?.leaseExpiresAt);
+      const model = realtimeModel(payload?.model);
+      if (realtimeId && operationId && version && connectionEpoch && leaseExpiresAt && model) {
+        projected = {
+          state: "active",
+          realtimeId,
+          operationId,
+          version,
+          connectionEpoch,
+          leaseExpiresAt,
+          model
+        };
+      }
+    } else if (event.type === "session.realtime.ended") {
+      const realtimeId = stringValue(payload?.realtimeId);
+      const operationId = stringValue(payload?.operationId);
+      const version = positiveInteger(payload?.version);
+      const connectionEpoch = positiveInteger(payload?.connectionEpoch);
+      const reason = endReason(payload?.reason);
+      if (realtimeId && operationId && version && connectionEpoch && reason) {
+        projected = {
+          state: "ended",
+          realtimeId,
+          operationId,
+          version,
+          connectionEpoch,
+          reason
+        };
+      }
+    }
+  }
+  return projected;
+}
+function realtimeModel(value) {
+  return value === "gpt-live-1-boulder-alpha" || value === "opengeni-gateway/openai/gpt-realtime-2.1" || value === "opengeni-gateway/openai/gpt-realtime-mini" || value === "opengeni-gateway/xai/grok-voice-think-fast-2.0" || value === "workspace-gateway/openai/gpt-realtime-2.1" || value === "workspace-gateway/openai/gpt-realtime-mini" || value === "workspace-gateway/xai/grok-voice-think-fast-2.0" ? value : null;
+}
+function recordValue(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function positiveInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : null;
+}
+function endReason(value) {
+  return value === "user_stop" || value === "browser_unload" || value === "lease_expired" ? value : null;
+}
+
+// src/codex-realtime-controller.ts
+var HEARTBEAT_INTERVAL_MS = 1e4;
+var OUTBOUND_SYNC_INTERVAL_MS = 1e3;
+var CODEX_REALTIME_NEGOTIATION_TIMEOUT_MS = 2e4;
+var DEFAULT_CONNECTION_ROTATION_INTERVAL_MS = 15 * 6e4;
+var DEFAULT_RECONNECT_BACKOFF_MS = [250, 1e3, 2e3, 5e3];
+var OWNER_RECORD_VERSION = 1;
+function createCodexRealtimeController(options) {
+  const storage = options.storage ?? defaultStorage();
+  const storageKey = ownerStorageKey(
+    options.workspaceId,
+    options.sessionId,
+    options.ownerStorageNamespace
+  );
+  const model = options.model ?? "gpt-live-1-boulder-alpha";
+  const randomUUID = options.randomUUID ?? defaultRandomUUID2;
+  const scheduleInterval = options.setInterval ?? ((callback, delay) => globalThis.setInterval(callback, delay));
+  const unscheduleInterval = options.clearInterval ?? ((handle) => globalThis.clearInterval(handle));
+  const scheduleTimeout = options.setTimeout ?? ((callback, delay) => globalThis.setTimeout(callback, delay));
+  const unscheduleTimeout = options.clearTimeout ?? ((handle) => globalThis.clearTimeout(handle));
+  const rotationInterval = positiveDuration(
+    options.connectionRotationIntervalMs ?? DEFAULT_CONNECTION_ROTATION_INTERVAL_MS,
+    "connection rotation interval"
+  );
+  const negotiationTimeout = positiveDuration(
+    options.negotiationTimeoutMs ?? CODEX_REALTIME_NEGOTIATION_TIMEOUT_MS,
+    "negotiation timeout"
+  );
+  const reconnectBackoff = validateReconnectBackoff(
+    options.reconnectBackoffMs ?? DEFAULT_RECONNECT_BACKOFF_MS
+  );
+  const listeners = /* @__PURE__ */ new Set();
+  let owner = readOwnerRecord(storage, storageKey, options);
+  let state = {
+    status: owner ? "recovering" : "idle",
+    realtimeId: null,
+    mode: null,
+    bridge: null,
+    microphone: "inactive",
+    inputMuted: false,
+    audibleOutput: "inactive",
+    outputMuted: false,
+    connectionGeneration: 0,
+    reconnectAttempt: 0,
+    diagnostic: null,
+    error: null
+  };
+  let active = null;
+  let pendingAbort = null;
+  let pendingGeneration = null;
+  let microphone = null;
+  let heartbeatTimer = null;
+  let syncTimer = null;
+  let rotationTimer = null;
+  let reconnectTimer = null;
+  let negotiationTimer = null;
+  let closed = false;
+  let stopping = false;
+  let generation = 0;
+  let reconnectAttempt = 0;
+  let recoveryTerminal = false;
+  let mutationTail = Promise.resolve();
+  let connectionTask = null;
+  const publish = (patch) => {
+    state = { ...state, ...patch };
+    for (const listener of listeners) listener({ ...state });
+  };
+  const diagnostic = (kind, message, recoverable, targetGeneration = state.connectionGeneration) => ({
+    kind,
+    message,
+    recoverable,
+    connectionGeneration: targetGeneration,
+    attempt: reconnectAttempt
+  });
+  const exclusive = async (operation) => {
+    const pending = mutationTail.then(operation, operation);
+    mutationTail = pending.then(
+      () => void 0,
+      () => void 0
+    );
+    return await pending;
+  };
+  const stopTimers = () => {
+    if (heartbeatTimer !== null) unscheduleInterval(heartbeatTimer);
+    if (syncTimer !== null) unscheduleInterval(syncTimer);
+    if (rotationTimer !== null) unscheduleTimeout(rotationTimer);
+    if (reconnectTimer !== null) unscheduleTimeout(reconnectTimer);
+    if (negotiationTimer !== null) unscheduleTimeout(negotiationTimer);
+    heartbeatTimer = null;
+    syncTimer = null;
+    rotationTimer = null;
+    reconnectTimer = null;
+    negotiationTimer = null;
+  };
+  const stopNegotiationTimers = () => {
+    if (heartbeatTimer !== null) unscheduleInterval(heartbeatTimer);
+    if (rotationTimer !== null) unscheduleTimeout(rotationTimer);
+    if (reconnectTimer !== null) unscheduleTimeout(reconnectTimer);
+    if (negotiationTimer !== null) unscheduleTimeout(negotiationTimer);
+    heartbeatTimer = null;
+    rotationTimer = null;
+    reconnectTimer = null;
+    negotiationTimer = null;
+  };
+  const clearNegotiationTimer = () => {
+    if (negotiationTimer !== null) unscheduleTimeout(negotiationTimer);
+    negotiationTimer = null;
+  };
+  const releaseMicrophone = () => {
+    const current = microphone;
+    microphone = null;
+    current?.getTracks().forEach((track) => track.stop());
+    publish({ microphone: "inactive" });
+  };
+  const closeActive = () => {
+    const current = active;
+    active = null;
+    current?.bridge.close();
+    current?.transport.stop();
+    publish({ bridge: null, audibleOutput: "inactive" });
+  };
+  const closeBrowserResources = (releaseMedia = true) => {
+    stopTimers();
+    pendingAbort?.abort(new DOMException("Codex realtime browser owner closed", "AbortError"));
+    pendingAbort = null;
+    pendingGeneration = null;
+    closeActive();
+    if (releaseMedia) releaseMicrophone();
+  };
+  const clearOwner = () => {
+    owner = null;
+    storage?.removeItem(storageKey);
+  };
+  const transitionEnded = (message = "Realtime mode ended") => {
+    stopping = false;
+    connectionTask = null;
+    closeBrowserResources();
+    clearOwner();
+    reconnectAttempt = 0;
+    recoveryTerminal = false;
+    publish({
+      status: "idle",
+      realtimeId: null,
+      mode: null,
+      bridge: null,
+      inputMuted: false,
+      outputMuted: false,
+      reconnectAttempt: 0,
+      diagnostic: diagnostic("terminal_stop", message, false),
+      error: null
+    });
+  };
+  const ensureMicrophone = async (replace, signal) => {
+    if (!replace && codexRealtimeMicrophoneHealthy(microphone)) return microphone;
+    releaseMicrophone();
+    publish({ microphone: "acquiring" });
+    try {
+      const acquired = await acquireCodexRealtimeMicrophone({
+        signal,
+        getUserMedia: options.getUserMedia
+      });
+      if (closed || stopping || signal.aborted) {
+        acquired.getTracks().forEach((track) => track.stop());
+        throw signal.reason ?? new DOMException("Aborted", "AbortError");
+      }
+      microphone = acquired;
+      for (const track of acquired.getAudioTracks()) track.enabled = !state.inputMuted;
+      publish({ microphone: "active" });
+      return acquired;
+    } catch (error) {
+      if (error instanceof CodexRealtimeMicrophoneError) {
+        const kind = error.code === "permission_denied" ? "permission_failure" : "device_failure";
+        publish({
+          microphone: error.code,
+          status: state.mode?.state === "active" ? "recovering" : "error",
+          diagnostic: diagnostic(kind, error.message, true),
+          error: error.message
+        });
+      }
+      throw error;
+    }
+  };
+  const syncForGeneration = async (targetGeneration, realtimeId, request) => await exclusive(async () => {
+    const current = state.mode;
+    if (!owner || !current || current.id !== realtimeId || current.state !== "active" || active?.generation !== targetGeneration) {
+      throw new Error("Codex realtime connection generation is no longer active");
+    }
+    return await options.client.syncSessionRealtimeLedger(
+      options.workspaceId,
+      options.sessionId,
+      realtimeId,
+      { ...request, expectedVersion: current.version }
+    );
+  });
+  const onAudibleOutput = (targetGeneration, next) => {
+    if (active?.generation !== targetGeneration || closed || stopping) return;
+    if (next === "blocked") {
+      const message = "Browser blocked audible realtime output. Use Resume audio to continue listening.";
+      publish({
+        audibleOutput: next,
+        diagnostic: diagnostic("autoplay_blocked", message, true),
+        error: message
+      });
+      return;
+    }
+    publish({ audibleOutput: next, ...next === "audible" ? { error: null } : {} });
+  };
+  const startActiveIntervals = () => {
+    if (heartbeatTimer === null) {
+      heartbeatTimer = scheduleInterval(() => {
+        void heartbeat().catch((error) => {
+          if (!closed && !stopping) {
+            publish({ error: safeError2(error) });
+            scheduleRecovery("reconnect", false);
+          }
+        });
+      }, HEARTBEAT_INTERVAL_MS);
+    }
+    if (syncTimer === null) {
+      syncTimer = scheduleInterval(() => {
+        void flush().catch((error) => {
+          if (!closed && !stopping) publish({ error: safeError2(error) });
+        });
+      }, OUTBOUND_SYNC_INTERVAL_MS);
+    }
+  };
+  const scheduleRecovery = (cause, replaceMicrophone, immediate = false) => {
+    if (closed || stopping || recoveryTerminal || !owner || state.mode?.state !== "active") return;
+    if (connectionTask || reconnectTimer !== null) return;
+    if (rotationTimer !== null) unscheduleTimeout(rotationTimer);
+    rotationTimer = null;
+    startActiveIntervals();
+    const kind = cause === "rotation" ? "rotation" : cause === "microphone" ? "device_failure" : "reconnect";
+    const message = cause === "rotation" ? "Rotating the finite provider connection" : cause === "microphone" ? "Recovering microphone and realtime connection" : "Recovering the realtime provider connection";
+    publish({
+      status: "recovering",
+      reconnectAttempt,
+      diagnostic: diagnostic(kind, message, true),
+      error: cause === "rotation" ? null : message
+    });
+    const delay = immediate ? 0 : reconnectBackoff[Math.min(reconnectAttempt, reconnectBackoff.length - 1)];
+    reconnectTimer = scheduleTimeout(() => {
+      reconnectTimer = null;
+      const record2 = owner;
+      const mode = state.mode;
+      if (connectionTask || !record2 || !mode || closed || stopping || mode.state !== "active") {
+        return;
+      }
+      connectionTask = establish(record2, mode, cause, true, replaceMicrophone).then(() => {
+        reconnectAttempt = 0;
+        publish({ reconnectAttempt: 0 });
+      }).catch(async (error) => {
+        connectionTask = null;
+        await handleConnectionFailure(error, cause, replaceMicrophone);
+      }).finally(() => {
+        connectionTask = null;
+      });
+    }, delay);
+  };
+  const handleConnectionFailure = async (error, cause, replaceMicrophone) => {
+    if (closed || stopping || isAbortError(error)) return;
+    const message = safeError2(error);
+    if (error instanceof CodexRealtimeMicrophoneError) {
+      if (error.code === "track_ended" && state.mode?.state === "active") {
+        reconnectAttempt += 1;
+        publish({
+          status: "recovering",
+          microphone: error.code,
+          reconnectAttempt,
+          diagnostic: diagnostic("device_failure", error.message, true),
+          error: error.message
+        });
+        scheduleRecovery("microphone", true);
+      } else if (state.mode?.state === "active") {
+        startActiveIntervals();
+      }
+      return;
+    }
+    if (error instanceof OpenGeniApiError && error.status === 404) {
+      transitionEnded("Realtime owner no longer exists");
+      return;
+    }
+    if (error instanceof OpenGeniApiError && error.status === 409 && error.retryable && owner) {
+      try {
+        const reconciled = await begin(owner, true, false);
+        if (!reconciled || reconciled.state === "ended") return;
+      } catch (reconcileError) {
+        if (reconcileError instanceof OpenGeniApiError && !reconcileError.retryable) {
+          stopTimers();
+          if (!active) releaseMicrophone();
+          recoveryTerminal = true;
+          publish({
+            status: "error",
+            diagnostic: diagnostic("negotiation_failure", safeError2(reconcileError), false),
+            error: safeError2(reconcileError)
+          });
+          return;
+        }
+      }
+    } else if (error instanceof OpenGeniApiError && !error.retryable) {
+      stopTimers();
+      if (!active) releaseMicrophone();
+      recoveryTerminal = true;
+      publish({
+        status: "error",
+        diagnostic: diagnostic("negotiation_failure", message, false),
+        error: message
+      });
+      return;
+    }
+    reconnectAttempt += 1;
+    publish({
+      status: "recovering",
+      reconnectAttempt,
+      diagnostic: diagnostic("negotiation_failure", message, true),
+      error: message
+    });
+    scheduleRecovery(cause === "rotation" ? "reconnect" : cause, replaceMicrophone);
+  };
+  const onBridgeFatal = (targetGeneration, failedBridge, fatal) => {
+    const current = active;
+    if (closed || stopping || !current || current.generation !== targetGeneration) return;
+    active = null;
+    failedBridge.close();
+    current.transport.stop();
+    publish({
+      status: "recovering",
+      bridge: failedBridge.snapshot(),
+      audibleOutput: "inactive",
+      diagnostic: diagnostic("negotiation_failure", fatal.message, true, targetGeneration),
+      error: fatal.message
+    });
+    scheduleRecovery("reconnect", false, true);
+  };
+  const onConnectionHealth = (targetGeneration, health) => {
+    if (closed || stopping) return;
+    if (pendingGeneration === targetGeneration && health !== "connected") {
+      pendingAbort?.abort(new Error(`Codex realtime replacement ${health} before activation`));
+      return;
+    }
+    if (active?.generation !== targetGeneration || health === "connected") return;
+    scheduleRecovery("reconnect", false);
+  };
+  const onMicrophoneEnded = (targetGeneration) => {
+    if (closed || stopping) return;
+    const error = new CodexRealtimeMicrophoneError(
+      "track_ended",
+      "The microphone device was disconnected"
+    );
+    publish({
+      microphone: "track_ended",
+      diagnostic: diagnostic("device_failure", error.message, true),
+      error: error.message
+    });
+    if (pendingGeneration === targetGeneration) {
+      pendingAbort?.abort(error);
+      return;
+    }
+    if (active?.generation !== targetGeneration) return;
+    scheduleRecovery("microphone", true, true);
+  };
+  const startTimers = () => {
+    stopTimers();
+    startActiveIntervals();
+    rotationTimer = scheduleTimeout(() => {
+      rotationTimer = null;
+      scheduleRecovery("rotation", false, true);
+    }, rotationInterval);
+  };
+  const establish = async (record2, currentMode, cause, rotate, replaceMicrophone) => {
+    if (currentMode.state !== "active") {
+      transitionEnded();
+      return;
+    }
+    if (rotate) {
+      await heartbeat();
+      const renewedMode = state.mode;
+      if (!renewedMode || renewedMode.state !== "active") return;
+      if (closed || stopping || owner !== record2) {
+        throw new DOMException("Realtime connection generation was retired", "AbortError");
+      }
+      currentMode = renewedMode;
+    }
+    stopNegotiationTimers();
+    const targetGeneration = ++generation;
+    pendingGeneration = targetGeneration;
+    const abort = new AbortController();
+    pendingAbort = abort;
+    const earlyEvents = createCodexRealtimeEarlyEventBuffer({
+      onFatal: (error) => {
+        if (pendingGeneration === targetGeneration && !abort.signal.aborted) abort.abort(error);
+      }
+    });
+    negotiationTimer = scheduleTimeout(() => {
+      if (pendingGeneration === targetGeneration && !abort.signal.aborted) {
+        abort.abort(
+          new CodexRealtimeGenerationError(
+            "Codex realtime negotiation did not open within 20 seconds"
+          )
+        );
+      }
+    }, negotiationTimeout);
+    publish({
+      status: rotate ? "recovering" : "starting",
+      realtimeId: currentMode.id,
+      mode: currentMode,
+      connectionGeneration: targetGeneration,
+      diagnostic: cause === "rotation" ? diagnostic(
+        "rotation",
+        "Rotating the finite provider connection",
+        true,
+        targetGeneration
+      ) : cause === "reload" || cause === "reconnect" ? diagnostic("reconnect", "Reconnecting the same realtime mode", true, targetGeneration) : state.diagnostic,
+      error: null
+    });
+    let connected;
+    try {
+      const media = await ensureMicrophone(replaceMicrophone, abort.signal);
+      const operationId = randomUUID();
+      const commonTransportInput = {
+        client: options.client,
+        workspaceId: options.workspaceId,
+        sessionId: options.sessionId,
+        realtimeId: currentMode.id,
+        operationId,
+        browserInstanceId: record2.browserInstanceId,
+        ownerKey: record2.ownerKey,
+        expectedVersion: currentMode.version,
+        expectedConnectionEpoch: currentMode.connectionEpoch,
+        rotate,
+        signal: abort.signal,
+        media,
+        onEventsCreated: earlyEvents.attach,
+        onAudibleOutputState: (next) => onAudibleOutput(targetGeneration, next),
+        onMicrophoneEnded: () => onMicrophoneEnded(targetGeneration),
+        onConnectionHealth: (health) => onConnectionHealth(targetGeneration, health)
+      };
+      connected = options.startTransport ? await options.startTransport(commonTransportInput) : await startCodexRealtimeWebrtc({
+        ...commonTransportInput,
+        remoteAudio: options.remoteAudio,
+        activateRemoteAudio: false,
+        createPeerConnection: options.createPeerConnection,
+        getUserMedia: options.getUserMedia,
+        negotiate: async (request, requestOptions) => await options.client.negotiateCodexRealtimeWebrtc(
+          options.workspaceId,
+          options.sessionId,
+          request,
+          requestOptions
+        )
+      });
+    } catch (error) {
+      clearNegotiationTimer();
+      earlyEvents.close();
+      if (pendingGeneration === targetGeneration) {
+        pendingGeneration = null;
+        pendingAbort = null;
+      }
+      throw error;
+    }
+    try {
+      await waitForDataChannelOpen(connected.events, abort.signal);
+      if (closed || stopping || abort.signal.aborted || pendingGeneration !== targetGeneration || !connected.microphoneHealthy()) {
+        if (!connected.microphoneHealthy() && !abort.signal.aborted) {
+          abort.abort(
+            new CodexRealtimeMicrophoneError(
+              "track_ended",
+              "The microphone audio track ended before realtime activation"
+            )
+          );
+        }
+        throw abort.signal.reason ?? new DOMException("Aborted", "AbortError");
+      }
+      const activated = await options.client.activateCodexRealtimeConnection(
+        options.workspaceId,
+        options.sessionId,
+        currentMode.id,
+        connected.connectionId,
+        {
+          operationId: connected.operationId,
+          browserInstanceId: record2.browserInstanceId,
+          ownerKey: record2.ownerKey,
+          connectionEpoch: connected.connectionEpoch,
+          expectedVersion: currentMode.version,
+          expectedConnectionEpoch: currentMode.connectionEpoch
+        },
+        { signal: abort.signal }
+      );
+      if (activated.mode.state !== "active") {
+        clearNegotiationTimer();
+        earlyEvents.close();
+        connected.stop();
+        transitionEnded();
+        return;
+      }
+      if (closed || stopping || abort.signal.aborted || pendingGeneration !== targetGeneration || !connected.microphoneHealthy()) {
+        if (!connected.microphoneHealthy() && !abort.signal.aborted) {
+          abort.abort(
+            new CodexRealtimeMicrophoneError(
+              "track_ended",
+              "The microphone audio track ended during realtime activation"
+            )
+          );
+        }
+        throw abort.signal.reason ?? new DOMException("Aborted", "AbortError");
+      }
+      clearNegotiationTimer();
+      const previous = active;
+      let bridge;
+      bridge = createCodexRealtimeV3Bridge({
+        events: connected.events,
+        connectionId: connected.connectionId,
+        connectionEpoch: connected.connectionEpoch,
+        startupFenceSequence: connected.startupFenceSequence,
+        modeVersion: activated.mode.version,
+        owner: {
+          browserInstanceId: record2.browserInstanceId,
+          ownerKey: record2.ownerKey,
+          expectedVersion: activated.mode.version
+        },
+        listen: false,
+        sync: async (request) => await syncForGeneration(targetGeneration, activated.mode.id, request),
+        randomUUID,
+        onSnapshot: (nextBridge) => {
+          if (active?.generation === targetGeneration) publish({ bridge: nextBridge });
+        },
+        onFatal: (fatal) => onBridgeFatal(targetGeneration, bridge, fatal)
+      });
+      active = { generation: targetGeneration, transport: connected, bridge };
+      connected.setOutputMuted(state.outputMuted);
+      recoveryTerminal = false;
+      pendingAbort = null;
+      pendingGeneration = null;
+      publish({
+        status: "active",
+        realtimeId: activated.mode.id,
+        mode: activated.mode,
+        microphone: "active",
+        audibleOutput: connected.audibleOutputState(),
+        bridge: bridge.snapshot(),
+        connectionGeneration: targetGeneration,
+        reconnectAttempt: 0,
+        diagnostic: cause === "rotation" ? diagnostic(
+          "rotation",
+          "Provider connection rotation completed",
+          true,
+          targetGeneration
+        ) : cause === "reload" || cause === "reconnect" || cause === "microphone" ? diagnostic("reconnect", "Realtime connection recovered", true, targetGeneration) : null,
+        error: null
+      });
+      connected.activateRemoteAudio();
+      previous?.bridge.close();
+      previous?.transport.stop();
+      earlyEvents.handoff(bridge);
+      if (active?.generation !== targetGeneration) {
+        throw new CodexRealtimeGenerationError(
+          bridge.snapshot().fatal?.message ?? "Codex realtime connection generation was retired during activation"
+        );
+      }
+      startTimers();
+    } catch (error) {
+      clearNegotiationTimer();
+      earlyEvents.close();
+      connected.stop();
+      if (pendingGeneration === targetGeneration) {
+        pendingGeneration = null;
+        pendingAbort = null;
+      }
+      throw error;
+    }
+  };
+  const begin = async (record2, recover, connectAfterBegin = true) => {
+    const response = await options.client.beginSessionRealtime(
+      options.workspaceId,
+      options.sessionId,
+      {
+        operationId: record2.operationId,
+        browserInstanceId: record2.browserInstanceId,
+        ownerKey: record2.ownerKey,
+        model
+      }
+    );
+    if (response.mode.state !== "active") {
+      transitionEnded();
+      return null;
+    }
+    publish({ mode: response.mode, realtimeId: response.mode.id });
+    if (connectAfterBegin) {
+      await establish(
+        record2,
+        response.mode,
+        recover ? "reload" : "manual",
+        recover || response.replay,
+        false
+      );
+    }
+    return response.mode;
+  };
+  const heartbeat = async () => {
+    await exclusive(async () => {
+      const current = state.mode;
+      if (!owner || !current || current.state !== "active") {
+        throw new Error("Codex realtime owner is not active");
+      }
+      const result = await options.client.heartbeatSessionRealtime(
+        options.workspaceId,
+        options.sessionId,
+        current.id,
+        {
+          browserInstanceId: owner.browserInstanceId,
+          ownerKey: owner.ownerKey,
+          expectedVersion: current.version
+        }
+      );
+      if (result.mode.state === "ended") {
+        transitionEnded("Realtime lease ended");
+        return;
+      }
+      publish({ mode: result.mode, realtimeId: result.mode.id, error: null });
+    });
+  };
+  const flush = async () => {
+    await active?.bridge.flush();
+  };
+  const retry = async () => {
+    if (!owner || state.mode?.state !== "active") {
+      throw new Error("Codex realtime owner is not recoverable");
+    }
+    if (recoveryTerminal || state.diagnostic?.recoverable === false) {
+      throw new Error("Codex realtime recovery is terminal; stop the mode before retrying");
+    }
+    if (reconnectTimer !== null) unscheduleTimeout(reconnectTimer);
+    reconnectTimer = null;
+    const replace = !codexRealtimeMicrophoneHealthy(microphone);
+    scheduleRecovery(replace ? "microphone" : "manual", replace, true);
+  };
+  const retryAudibleOutput = async () => {
+    if (!active || state.audibleOutput !== "blocked") return false;
+    const target = active;
+    const resumed = await target.transport.retryAudibleOutput();
+    if (active?.generation !== target.generation) return false;
+    return resumed;
+  };
+  const setInputMuted = (muted) => {
+    if (state.inputMuted === muted) return;
+    for (const track of microphone?.getAudioTracks() ?? []) track.enabled = !muted;
+    publish({ inputMuted: muted });
+  };
+  const setOutputMuted = (muted) => {
+    if (state.outputMuted === muted) return;
+    active?.transport.setOutputMuted(muted);
+    publish({ outputMuted: muted });
+  };
+  const controller = {
+    snapshot: () => ({ ...state }),
+    subscribe: (listener) => {
+      listeners.add(listener);
+      listener({ ...state });
+      return () => listeners.delete(listener);
+    },
+    start: async () => {
+      if (state.status === "lost_owner") {
+        throw new Error("Realtime mode belongs to another browser owner");
+      }
+      if (!["idle", "error"].includes(state.status) || state.mode?.state === "active") return;
+      closed = false;
+      stopping = false;
+      recoveryTerminal = false;
+      const record2 = {
+        version: OWNER_RECORD_VERSION,
+        workspaceId: options.workspaceId,
+        sessionId: options.sessionId,
+        browserInstanceId: randomUUID(),
+        ownerKey: `opengeni-realtime-owner:${randomUUID()}`,
+        operationId: randomUUID()
+      };
+      owner = record2;
+      storage?.setItem(storageKey, JSON.stringify(record2));
+      publish({ status: "starting", error: null, diagnostic: null });
+      try {
+        await begin(record2, false);
+      } catch (error) {
+        closeBrowserResources(false);
+        const failedMode = state.mode;
+        if (failedMode?.state === "active") {
+          await handleConnectionFailure(error, "reconnect", false);
+        } else {
+          clearOwner();
+          publish({ status: "error", realtimeId: null, mode: null, error: safeError2(error) });
+        }
+        throw error;
+      }
+    },
+    observeLifecycle: async (lifecycle) => {
+      if (!lifecycle) {
+        if (recoveryTerminal && state.mode?.state === "active") return;
+        const record3 = readOwnerRecord(storage, storageKey, options);
+        if (!record3) {
+          transitionEnded();
+          return;
+        }
+        if (connectionTask || state.status === "starting" || state.status === "active") return;
+        closed = false;
+        stopping = false;
+        owner = record3;
+        publish({ status: "recovering", error: null });
+        connectionTask = begin(record3, true).then(() => void 0).catch(async (error) => {
+          connectionTask = null;
+          await handleConnectionFailure(error, "reload", false);
+        }).finally(() => {
+          connectionTask = null;
+        });
+        await connectionTask;
+        return;
+      }
+      if (lifecycle.state === "ended") {
+        const record3 = readOwnerRecord(storage, storageKey, options);
+        if (record3 && record3.operationId !== lifecycle.operationId) {
+          if (connectionTask || state.status === "active") return;
+          closed = false;
+          stopping = false;
+          owner = record3;
+          connectionTask = begin(record3, true).then(() => void 0).catch(async (error) => {
+            connectionTask = null;
+            await handleConnectionFailure(error, "reload", false);
+          }).finally(() => {
+            connectionTask = null;
+          });
+          await connectionTask;
+          return;
+        }
+        if (state.realtimeId === null || lifecycle.realtimeId === state.realtimeId) {
+          transitionEnded(`Realtime ended: ${lifecycle.reason}`);
+        }
+        return;
+      }
+      if (recoveryTerminal && state.realtimeId === lifecycle.realtimeId) return;
+      if (state.status === "active" && state.realtimeId === lifecycle.realtimeId) return;
+      const record2 = readOwnerRecord(storage, storageKey, options);
+      if (!record2 || record2.operationId !== lifecycle.operationId) {
+        closeBrowserResources();
+        owner = null;
+        const message = "Realtime is active in another browser owner. It can resume after that owner stops or its lease expires.";
+        publish({
+          status: "lost_owner",
+          realtimeId: lifecycle.realtimeId,
+          mode: null,
+          bridge: null,
+          diagnostic: diagnostic("lost_owner", message, false),
+          error: message
+        });
+        return;
+      }
+      if (connectionTask || state.status === "starting") return;
+      closed = false;
+      stopping = false;
+      owner = record2;
+      publish({ status: "recovering", realtimeId: lifecycle.realtimeId, error: null });
+      connectionTask = begin(record2, true).then(() => void 0).catch(async (error) => {
+        connectionTask = null;
+        await handleConnectionFailure(error, "reload", false);
+      }).finally(() => {
+        connectionTask = null;
+      });
+      await connectionTask;
+    },
+    heartbeat,
+    flush,
+    ingestProviderEvent: async (payload) => {
+      if (!active) throw new Error("Codex realtime provider channel is not connected");
+      await active.bridge.ingest(payload);
+    },
+    retry,
+    retryAudibleOutput,
+    setInputMuted,
+    setOutputMuted,
+    stop: async () => {
+      const currentOwner = owner;
+      if (!currentOwner || !state.mode) {
+        if (state.status !== "lost_owner") transitionEnded();
+        return;
+      }
+      stopping = true;
+      publish({
+        status: "stopping",
+        diagnostic: diagnostic("terminal_stop", "Stopping realtime and releasing media", false),
+        error: null
+      });
+      stopTimers();
+      pendingAbort?.abort(new DOMException("Realtime stopped", "AbortError"));
+      pendingGeneration = null;
+      const retiredTask = connectionTask;
+      connectionTask = null;
+      void retiredTask?.catch(() => void 0);
+      try {
+        await active?.bridge.sealAndFlush();
+        closeBrowserResources();
+        let current = state.mode;
+        if (!current) throw new Error("Codex realtime mode disappeared while stopping");
+        let response;
+        try {
+          response = await exclusive(
+            async () => await options.client.endSessionRealtime(
+              options.workspaceId,
+              options.sessionId,
+              current.id,
+              {
+                browserInstanceId: currentOwner.browserInstanceId,
+                ownerKey: currentOwner.ownerKey,
+                expectedVersion: current.version,
+                reason: "user_stop"
+              }
+            )
+          );
+        } catch (error) {
+          if (!(error instanceof OpenGeniApiError) || error.status !== 409) throw error;
+          const reconciled = await begin(currentOwner, true, false);
+          if (!reconciled || reconciled.state === "ended") return;
+          current = reconciled;
+          response = await exclusive(
+            async () => await options.client.endSessionRealtime(
+              options.workspaceId,
+              options.sessionId,
+              current.id,
+              {
+                browserInstanceId: currentOwner.browserInstanceId,
+                ownerKey: currentOwner.ownerKey,
+                expectedVersion: current.version,
+                reason: "user_stop"
+              }
+            )
+          );
+        }
+        if (response.mode.state === "ended") transitionEnded("Realtime stopped by this browser");
+      } catch (error) {
+        stopping = false;
+        owner = currentOwner;
+        startActiveIntervals();
+        publish({
+          status: "recovering",
+          diagnostic: diagnostic("terminal_stop", safeError2(error), true),
+          error: safeError2(error)
+        });
+        throw error;
+      }
+    },
+    close: () => {
+      closed = true;
+      stopping = false;
+      closeBrowserResources();
+      listeners.clear();
+    }
+  };
+  return controller;
+}
+function createCodexRealtimeEarlyEventBuffer(input) {
+  let events = null;
+  let buffered = [];
+  let bufferedBytes = 0;
+  let fatal = false;
+  const detach = () => {
+    events?.removeEventListener("message", onMessage);
+    events = null;
+  };
+  const fail = () => {
+    if (fatal) return;
+    fatal = true;
+    detach();
+    buffered = [];
+    bufferedBytes = 0;
+    input.onFatal(
+      new CodexRealtimeGenerationError(
+        "Codex realtime activation event buffer exceeded its hard limit"
+      )
+    );
+  };
+  const onMessage = (message) => {
+    if (fatal || typeof message.data !== "string") return;
+    const parsed = parseCodexRealtimeV3Event(message.data);
+    if (!parsed.ok || parsed.event.type === "output_audio.delta") return;
+    const bytes = new TextEncoder().encode(message.data).byteLength;
+    if (bytes > CODEX_REALTIME_V3_MAX_EVENT_BYTES || buffered.length + 1 > CODEX_REALTIME_V3_PENDING_MAX_ENTRIES || bufferedBytes + bytes > CODEX_REALTIME_V3_PENDING_MAX_BYTES) {
+      fail();
+      return;
+    }
+    buffered.push(message.data);
+    bufferedBytes += bytes;
+  };
+  return {
+    attach: (channel) => {
+      if (fatal || events === channel) return;
+      if (events) throw new Error("Codex realtime activation buffer is already attached");
+      events = channel;
+      events.addEventListener("message", onMessage);
+    },
+    handoff: (bridge) => {
+      if (fatal) {
+        bridge.close();
+        return;
+      }
+      for (let index = 0; index < buffered.length; index += 1) {
+        void bridge.ingest(buffered[index]).catch(() => void 0);
+      }
+      buffered = [];
+      bufferedBytes = 0;
+      detach();
+      bridge.listen();
+    },
+    close: () => {
+      detach();
+      buffered = [];
+      bufferedBytes = 0;
+    }
+  };
+}
+var CodexRealtimeGenerationError = class extends Error {
+  name = "CodexRealtimeGenerationError";
+};
+function ownerStorageKey(workspaceId, sessionId, namespace = "codex-realtime-owner") {
+  return `opengeni:${namespace}:${workspaceId}:${sessionId}`;
+}
+function readOwnerRecord(storage, key, scope) {
+  const raw = storage?.getItem(key);
+  if (!raw) return null;
+  try {
+    const parsed = recordValue2(JSON.parse(raw));
+    if (parsed?.version !== OWNER_RECORD_VERSION || parsed.workspaceId !== scope.workspaceId || parsed.sessionId !== scope.sessionId || !stringValue2(parsed.operationId) || !stringValue2(parsed.browserInstanceId) || !stringValue2(parsed.ownerKey) || String(parsed.ownerKey).length < 32) {
+      storage?.removeItem(key);
+      return null;
+    }
+    return parsed;
+  } catch {
+    storage?.removeItem(key);
+    return null;
+  }
+}
+function defaultStorage() {
+  return typeof sessionStorage === "undefined" ? void 0 : sessionStorage;
+}
+function defaultRandomUUID2() {
+  if (!globalThis.crypto?.randomUUID) throw new Error("crypto.randomUUID is unavailable");
+  return globalThis.crypto.randomUUID();
+}
+function waitForDataChannelOpen(events, signal) {
+  if (signal.aborted) {
+    return Promise.reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+  }
+  if (events.readyState === "open") return Promise.resolve();
+  if (events.readyState === "closing" || events.readyState === "closed") {
+    return Promise.reject(new Error("Codex realtime data channel closed before opening"));
+  }
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      events.removeEventListener("open", onOpen);
+      events.removeEventListener("close", onClose);
+      events.removeEventListener("error", onError);
+      signal.removeEventListener("abort", onAbort);
+    };
+    const onOpen = () => {
+      cleanup();
+      resolve();
+    };
+    const onClose = () => {
+      cleanup();
+      reject(new Error("Codex realtime data channel closed before opening"));
+    };
+    const onError = () => {
+      cleanup();
+      reject(new Error("Codex realtime data channel failed before opening"));
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+    };
+    events.addEventListener("open", onOpen, { once: true });
+    events.addEventListener("close", onClose, { once: true });
+    events.addEventListener("error", onError, { once: true });
+    signal.addEventListener("abort", onAbort, { once: true });
+    if (signal.aborted) onAbort();
+    else if (events.readyState === "open") onOpen();
+    else if (events.readyState === "closing" || events.readyState === "closed") onClose();
+  });
+}
+function positiveDuration(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0)
+    throw new Error(`Codex realtime ${name} is invalid`);
+  return value;
+}
+function validateReconnectBackoff(values) {
+  if (values.length === 0 || values.some((value) => !Number.isSafeInteger(value) || value < 0 || value > 6e4)) {
+    throw new Error("Codex realtime reconnect backoff is invalid");
+  }
+  return [...values];
+}
+function recordValue2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function stringValue2(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+function safeError2(error) {
+  return error instanceof Error ? error.message : "Codex realtime browser controller failed";
+}
+
+export {
+  CODEX_REALTIME_CONTEXT_APPEND_MAX_BYTES,
+  parseCodexRealtimeV3Event,
+  encodeCodexRealtimeV3DelegationContextAppend,
+  encodeCodexRealtimeV3SessionContextAppend,
+  contextAppendChunks,
+  createCodexRealtimeV3Bridge,
+  CodexRealtimeMicrophoneError,
+  startCodexRealtimeWebrtc,
+  acquireCodexRealtimeMicrophone,
+  codexRealtimeMicrophoneHealthy,
+  projectSessionRealtimeLifecycle,
+  CODEX_REALTIME_NEGOTIATION_TIMEOUT_MS,
+  createCodexRealtimeController
+};
+//# sourceMappingURL=chunk-OB5PGV6N.js.map