@opengeni/sdk 0.36.1 → 0.40.0

package/README.md

@@ -37,6 +37,56 @@ for await (const event of client.streamEvents(workspaceId, session.id)) {
 }
 ```
 
+## Realtime browser controller (`@opengeni/sdk/realtime`)
+
+The public realtime subpath owns the provider-neutral browser controller and
+the existing Codex Live, WebRTC/V3, and AI Gateway transports. It selects the
+transport from the catalog model without changing the backend API, durable
+ledger, delegation, context, or recovery semantics:
+
+```ts
+import { OpenGeniClient } from "@opengeni/sdk";
+import type { SessionRealtimeClientLike } from "@opengeni/sdk/realtime";
+
+const client = new OpenGeniClient({ baseUrl: "/opengeni-api" });
+const realtimeClient: SessionRealtimeClientLike = client;
+const catalog = await realtimeClient.getWorkspaceRealtimeModelCatalog(workspaceId);
+const model = catalog.models.find((candidate) => candidate.available)?.id;
+if (!model) throw new Error("No realtime model is available");
+
+// Lazy import keeps the base SDK entry safe for server and non-realtime hosts.
+const { createSessionRealtimeController } = await import("@opengeni/sdk/realtime");
+const controller = createSessionRealtimeController({
+  client: realtimeClient,
+  workspaceId,
+  sessionId,
+  model,
+  remoteAudio,
+});
+
+const unsubscribe = controller.subscribe((snapshot) => {
+  console.log(snapshot.status, snapshot.microphone, snapshot.diagnostic);
+});
+await controller.start();
+
+// Later:
+await controller.stop();
+unsubscribe();
+controller.close();
+```
+
+`SessionRealtimeClientLike` is the exact proxy-friendly backend surface:
+catalog, begin, Codex/Gateway negotiation, activation, heartbeat, ledger sync,
+and end. Existing `OpenGeniClient` methods remain the implementation. Current
+Codex-named controller and transport exports remain available as compatibility
+aliases, but new integrations should use the provider-neutral names.
+
+Do not put API credentials in browser bundles. Browser hosts should either use
+the deployment's normal browser authentication or expose these same methods
+through a tenant-scoped, same-origin proxy. The SDK does not move persistence,
+prompt construction, context processing, delegation, or provider credentials
+out of `apps/api`, `apps/worker`, or `packages/db`.
+
 ## Workspace artifacts
 
 Workspace artifacts are generic, immutable HTML publications. The SDK does not
@@ -239,6 +289,11 @@ const paused = await client.getQueue(workspaceId, sessionId);
 await client.resumeSession(workspaceId, sessionId, {
   expectedControlEtag: paused.effectiveControl.controlEtag,
 });
+// Cancel is irreversible: it drains and fences this session subtree.
+await client.cancelSession(workspaceId, sessionId, {
+  reason: "host record deleted",
+  clientEventId: crypto.randomUUID(),
+});
 await client.sendApprovalDecision(workspaceId, sessionId, { approvalId, decision: "approve" });
 ```
 
@@ -348,14 +403,14 @@ Every public endpoint group has typed methods:
 | Group | Methods |
 | --- | --- |
 | Access + workspaces | `getAccessContext`, `listWorkspaces`, `createWorkspace`, `getWorkspace`, `updateWorkspace` |
-| Sessions + events | `createSession`, `listSessions`, `getSession`, `updateSession`, `listEvents`, `sendEvent`, `sendMessage`, `steerMessage`, `pauseSession`, `resumeSession`, `sendApprovalDecision`, `streamEvents`, `openEventStream` |
+| Sessions + events | `createSession`, `listSessions`, `getSession`, `updateSession`, `listEvents`, `sendEvent`, `sendMessage`, `steerMessage`, `pauseSession`, `resumeSession`, `cancelSession`, `sendApprovalDecision`, `streamEvents`, `openEventStream` |
 | Machines (bring-your-own-compute) | `listMachines`, `machineMetricsSeries`, `swapActiveSandbox`, `mintEnrollToken`, `lookupDeviceEnrollment`, `approveDeviceEnrollment`, `denyDeviceEnrollment` |
 | Turn queue | `getQueue`, `moveQueueItem`, `editQueueItem`, `steerQueueItem`, `deleteQueueItem` |
 | Goal | `getGoal`, `updateGoal`, `pauseGoal`, `resumeGoal` |
 | Scheduled tasks | `createScheduledTask`, `listScheduledTasks`, `getScheduledTask`, `updateScheduledTask`, `pauseScheduledTask`, `resumeScheduledTask`, `triggerScheduledTask`, `deleteScheduledTask`, `listScheduledTaskRuns` |
 | Variable sets | `listVariable sets`, `createVariable set`, `getVariable set`, `updateVariable set`, `deleteVariable set`, `setVariable setVariable`, `deleteVariable setVariable` (values are write-only) |
 | Files | `uploadFile`, `beginFileUpload`, `completeFileUpload`, `getFile`, `createFileDownloadUrl` |
-| Documents | `createDocumentBase`, `listDocumentBases`, `getDocumentBase`, `addDocument`, `listDocuments`, `reindexDocument`, `searchDocuments` |
+| Documents | `createDocumentBase`, `listDocumentBases`, `getDocumentBase`, `addDocument`, `listDocuments`, `reindexDocument`, `searchDocuments`, `searchKnowledge` (effective organization + workspace + immutable initiating-user personal scope) |
 | Packs | `listPacks`, `registerPack`, `getPack`, `enablePack`, `deletePack`, `listPackInstallations` |
 | Capabilities | `listCapabilities`, `createCapability`, `enableCapability`, `disableCapability`, `discoverMcpCapabilities` |
 | GitHub | `getGitHubApp`, `githubConnectUrl`, `listGitHubRepositories`, `syncGitHubRepositories`, `createGitHubAppManifest` |

package/dist/chunk-DXDL7EEW.js

@@ -0,0 +1,573 @@
+// src/gateway-realtime-transport.ts
+var AUDIO_SAMPLE_RATE = 24e3;
+var DELEGATION_TOOL = "delegate_to_session";
+function createGatewayRealtimeTransportStarter() {
+  return async (input) => {
+    const client = input.client;
+    if (!client.negotiateGatewayRealtime) {
+      throw new Error("The OpenGeni client does not support AI Gateway realtime");
+    }
+    const answer = await client.negotiateGatewayRealtime(
+      input.workspaceId,
+      input.sessionId,
+      {
+        realtimeId: input.realtimeId,
+        operationId: input.operationId,
+        browserInstanceId: input.browserInstanceId,
+        ownerKey: input.ownerKey,
+        expectedVersion: input.expectedVersion,
+        expectedConnectionEpoch: input.expectedConnectionEpoch,
+        rotate: input.rotate
+      },
+      { signal: input.signal }
+    );
+    throwIfAborted(input.signal);
+    const websocket = new WebSocket(answer.url, [
+      "ai-gateway-realtime.v1",
+      `ai-gateway-auth.${answer.token}`
+    ]);
+    const channel = new GatewayRealtimeDataChannel(
+      (payload) => handleBridgeOutbound(websocket, payload)
+    );
+    input.onEventsCreated(channel.asRtcDataChannel());
+    const audio = new GatewayRealtimeAudio({
+      onAudio: (encoded) => send(websocket, { type: "input-audio-append", audio: encoded }),
+      onAudibleOutputState: input.onAudibleOutputState
+    });
+    let stopped = false;
+    let currentOutputItemId = null;
+    const finalizedAssistantItems = /* @__PURE__ */ new Set();
+    const microphoneTracks = input.media.getAudioTracks();
+    const onMicrophoneEnded = () => {
+      if (!stopped) input.onMicrophoneEnded();
+    };
+    for (const track of microphoneTracks) track.addEventListener?.("ended", onMicrophoneEnded);
+    const onMessage = (event) => {
+      if (typeof event.data !== "string") return;
+      let parsed;
+      try {
+        parsed = JSON.parse(event.data);
+      } catch {
+        return;
+      }
+      if (!isRecord(parsed) || typeof parsed.type !== "string") return;
+      handleGatewayEvent({
+        event: parsed,
+        channel,
+        websocket,
+        audio,
+        finalizedAssistantItems,
+        getCurrentOutputItemId: () => currentOutputItemId,
+        setCurrentOutputItemId: (value) => {
+          currentOutputItemId = value;
+        }
+      });
+    };
+    const onClose = () => {
+      if (!stopped) input.onConnectionHealth("closed");
+    };
+    const onError = () => {
+      if (!stopped) input.onConnectionHealth("failed");
+    };
+    websocket.addEventListener("message", onMessage);
+    websocket.addEventListener("close", onClose);
+    websocket.addEventListener("error", onError);
+    await waitForWebSocketOpen(websocket, input.signal);
+    channel.open();
+    send(websocket, {
+      type: "session-update",
+      config: {
+        instructions: answer.instructions,
+        outputModalities: ["audio"],
+        inputAudioFormat: { type: "audio/pcm", rate: AUDIO_SAMPLE_RATE },
+        outputAudioFormat: { type: "audio/pcm", rate: AUDIO_SAMPLE_RATE },
+        inputAudioTranscription: {},
+        outputAudioTranscription: {},
+        turnDetection: {
+          type: "server-vad",
+          prefixPaddingMs: 300,
+          silenceDurationMs: 500
+        },
+        tools: [
+          {
+            type: "function",
+            name: DELEGATION_TOOL,
+            description: "Pass execution work, actions, and session tasks to the underlying session agent. Include the complete standalone request and relevant conversational context.",
+            parameters: {
+              type: "object",
+              properties: {
+                request: {
+                  type: "string",
+                  description: "Complete standalone task for the session agent"
+                }
+              },
+              required: ["request"],
+              additionalProperties: false
+            }
+          }
+        ]
+      }
+    });
+    for (const item of answer.initialItems) {
+      send(websocket, {
+        type: "conversation-item-create",
+        item: {
+          type: "text-message",
+          role: "user",
+          text: `<session_initial_item role="${item.role}">
+${item.text}
+</session_initial_item>`
+        }
+      });
+    }
+    await audio.startCapture(input.media);
+    input.onConnectionHealth("connected");
+    const stop = () => {
+      if (stopped) return;
+      stopped = true;
+      input.signal.removeEventListener("abort", stop);
+      websocket.removeEventListener("message", onMessage);
+      websocket.removeEventListener("close", onClose);
+      websocket.removeEventListener("error", onError);
+      for (const track of microphoneTracks) track.removeEventListener?.("ended", onMicrophoneEnded);
+      channel.close();
+      audio.dispose();
+      if (websocket.readyState === WebSocket.OPEN || websocket.readyState === WebSocket.CONNECTING) {
+        websocket.close(1e3, "OpenGeni realtime connection retired");
+      }
+    };
+    input.signal.addEventListener("abort", stop, { once: true });
+    return {
+      peerConnection: null,
+      events: channel.asRtcDataChannel(),
+      media: input.media,
+      operationId: input.operationId,
+      connectionId: answer.connectionId,
+      connectionEpoch: answer.connectionEpoch,
+      startupFenceSequence: answer.startupFenceSequence,
+      modeVersion: answer.modeVersion,
+      microphoneHealthy: () => microphoneTracks.length > 0 && microphoneTracks.every((track) => track.readyState !== "ended"),
+      audibleOutputState: () => audio.audibleOutputState(),
+      setOutputMuted: (muted) => audio.setMuted(muted),
+      activateRemoteAudio: () => void audio.resume(),
+      retryAudibleOutput: () => audio.resume(),
+      stop
+    };
+  };
+}
+function handleGatewayEvent(input) {
+  const event = input.event;
+  const eventId = providerEventId(event);
+  if (event.type === "session-created") {
+    const sessionId = stringValue(event.sessionId) ?? `gateway-${crypto.randomUUID()}`;
+    input.channel.providerEvent({
+      type: "session.started",
+      event_id: eventId,
+      session: { id: sessionId }
+    });
+    return;
+  }
+  if (event.type === "speech-started") {
+    const itemId = input.getCurrentOutputItemId();
+    if (itemId && input.audio.isPlaying()) {
+      const audioEndMs = input.audio.playbackOffsetMs();
+      input.audio.stopPlayback();
+      send(input.websocket, {
+        type: "conversation-item-truncate",
+        itemId,
+        contentIndex: 0,
+        audioEndMs: Math.max(0, Math.round(audioEndMs))
+      });
+    }
+    return;
+  }
+  if (event.type === "input-transcription-completed") {
+    const transcript = stringValue(event.transcript) ?? "";
+    const itemId = stringValue(event.itemId) ?? crypto.randomUUID();
+    if (transcript.trim()) {
+      input.channel.providerEvent({
+        type: "turn.done",
+        event_id: eventId,
+        turn: { id: itemId, role: "user", transcript }
+      });
+    }
+    return;
+  }
+  if (event.type === "audio-delta") {
+    const delta = stringValue(event.delta);
+    if (!delta) return;
+    const itemId = stringValue(event.itemId);
+    if (itemId) input.setCurrentOutputItemId(itemId);
+    input.audio.play(delta);
+    input.channel.providerEvent({ type: "output_audio.delta", event_id: eventId, audio: delta });
+    return;
+  }
+  if (event.type === "audio-transcript-done" || event.type === "text-done") {
+    const itemId = stringValue(event.itemId) ?? crypto.randomUUID();
+    const transcript = stringValue(event.transcript) ?? stringValue(event.text) ?? "";
+    if (transcript.trim() && !input.finalizedAssistantItems.has(itemId)) {
+      input.finalizedAssistantItems.add(itemId);
+      input.channel.providerEvent({
+        type: "turn.done",
+        event_id: eventId,
+        turn: { id: itemId, role: "assistant", transcript }
+      });
+    }
+    return;
+  }
+  if (event.type === "audio-done") return;
+  if (event.type === "function-call-arguments-done") {
+    const callId = stringValue(event.callId) ?? stringValue(event.itemId) ?? crypto.randomUUID();
+    const name = stringValue(event.name);
+    if (name !== DELEGATION_TOOL) {
+      send(input.websocket, {
+        type: "conversation-item-create",
+        item: {
+          type: "function-call-output",
+          callId,
+          name,
+          output: JSON.stringify({ error: "Unsupported realtime tool" })
+        }
+      });
+      send(input.websocket, { type: "response-create" });
+      return;
+    }
+    const request = delegationRequest(stringValue(event.arguments) ?? "");
+    input.channel.providerEvent({
+      type: "delegation.created",
+      event_id: eventId,
+      item: {
+        id: callId,
+        type: "delegation",
+        target: "client",
+        content: [{ type: "input_text", text: request }]
+      }
+    });
+    return;
+  }
+  if (event.type === "error") {
+    input.channel.providerEvent({
+      type: "error",
+      event_id: eventId,
+      message: stringValue(event.message) ?? "AI Gateway realtime provider error"
+    });
+  }
+}
+var GatewayRealtimeDataChannel = class extends EventTarget {
+  constructor(outbound) {
+    super();
+    this.outbound = outbound;
+  }
+  readyState = "connecting";
+  pendingOutbound = [];
+  outboundScheduled = false;
+  asRtcDataChannel() {
+    return this;
+  }
+  open() {
+    this.readyState = "open";
+    this.dispatchEvent(new Event("open"));
+  }
+  send(payload) {
+    if (this.readyState !== "open") throw new Error("Gateway realtime channel is not open");
+    let parsed;
+    try {
+      parsed = JSON.parse(payload);
+    } catch {
+      return;
+    }
+    if (!isRecord(parsed)) return;
+    this.pendingOutbound.push(parsed);
+    if (this.outboundScheduled) return;
+    this.outboundScheduled = true;
+    queueMicrotask(() => {
+      this.outboundScheduled = false;
+      const messages = this.pendingOutbound;
+      this.pendingOutbound = [];
+      if (messages.length > 0 && this.readyState === "open") this.outbound(messages);
+    });
+  }
+  providerEvent(event) {
+    if (this.readyState === "closed") return;
+    this.dispatchEvent(new MessageEvent("message", { data: JSON.stringify(event) }));
+  }
+  close() {
+    if (this.readyState === "closed") return;
+    this.readyState = "closed";
+    this.pendingOutbound = [];
+    this.dispatchEvent(new Event("close"));
+  }
+};
+function handleBridgeOutbound(websocket, messages) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    const type = stringValue(message.type);
+    if (type !== "session.context.append" && type !== "delegation.context.append") continue;
+    const id = stringValue(message.delegation_item_id) ?? null;
+    const channel = stringValue(message.channel) ?? "commentary";
+    const key = `${type}:${id ?? "session"}:${channel}`;
+    const content = Array.isArray(message.content) ? message.content : [];
+    const text = content.filter(isRecord).map((part) => stringValue(part.text) ?? "").join("");
+    const existing = groups.get(key);
+    groups.set(key, {
+      type,
+      id,
+      channel,
+      text: `${existing?.text ?? ""}${text}`
+    });
+  }
+  for (const group of groups.values()) {
+    if (group.type === "delegation.context.append" && group.id && group.channel === "speakable") {
+      send(websocket, {
+        type: "conversation-item-create",
+        item: {
+          type: "function-call-output",
+          callId: group.id,
+          name: DELEGATION_TOOL,
+          output: JSON.stringify({ result: group.text })
+        }
+      });
+      send(websocket, { type: "response-create" });
+      continue;
+    }
+    const wrapper = group.type === "delegation.context.append" ? group.channel === "commentary" ? "execution_progress" : "execution_result" : "session_update";
+    send(websocket, {
+      type: "conversation-item-create",
+      item: {
+        type: "text-message",
+        role: "user",
+        text: `<${wrapper}>
+${group.text}
+</${wrapper}>`
+      }
+    });
+    if (group.channel === "speakable") send(websocket, { type: "response-create" });
+  }
+}
+var GatewayRealtimeAudio = class {
+  constructor(options) {
+    this.options = options;
+  }
+  captureContext = null;
+  captureSource = null;
+  captureProcessor = null;
+  playbackContext = null;
+  playbackGain = null;
+  playbackTime = 0;
+  playbackStartedAt = 0;
+  activeSources = /* @__PURE__ */ new Set();
+  outputState = "inactive";
+  muted = false;
+  async startCapture(media) {
+    const context = new AudioContext({ sampleRate: AUDIO_SAMPLE_RATE });
+    this.captureContext = context;
+    const source = context.createMediaStreamSource(media);
+    const processor = context.createScriptProcessor(4096, 1, 1);
+    this.captureSource = source;
+    this.captureProcessor = processor;
+    processor.onaudioprocess = (event) => {
+      const samples = resample(
+        new Float32Array(event.inputBuffer.getChannelData(0)),
+        context.sampleRate,
+        AUDIO_SAMPLE_RATE
+      );
+      this.options.onAudio(encodePcm16(samples));
+    };
+    source.connect(processor);
+    processor.connect(context.destination);
+    await context.resume();
+  }
+  play(encoded) {
+    const context = this.playbackContext ??= new AudioContext({ sampleRate: AUDIO_SAMPLE_RATE });
+    if (context.state !== "running") {
+      void this.resume().then((resumed) => {
+        if (resumed) this.schedule(encoded);
+      });
+      return;
+    }
+    this.schedule(encoded);
+  }
+  schedule(encoded) {
+    const context = this.playbackContext;
+    if (!context) return;
+    const samples = decodePcm16(encoded);
+    const buffer = context.createBuffer(1, samples.length, AUDIO_SAMPLE_RATE);
+    buffer.getChannelData(0).set(samples);
+    const source = context.createBufferSource();
+    source.buffer = buffer;
+    source.connect(this.outputNode(context));
+    const startAt = Math.max(context.currentTime, this.playbackTime);
+    if (this.activeSources.size === 0) this.playbackStartedAt = startAt;
+    source.start(startAt);
+    this.playbackTime = startAt + buffer.duration;
+    this.activeSources.add(source);
+    this.publish("audible");
+    source.onended = () => {
+      this.activeSources.delete(source);
+      if (this.activeSources.size === 0) this.publish("inactive");
+    };
+  }
+  stopPlayback() {
+    for (const source of this.activeSources) {
+      try {
+        source.stop();
+      } catch {
+      }
+    }
+    this.activeSources.clear();
+    if (this.playbackContext) this.playbackTime = this.playbackContext.currentTime;
+    this.publish("inactive");
+  }
+  playbackOffsetMs() {
+    return this.playbackContext ? Math.max(0, (this.playbackContext.currentTime - this.playbackStartedAt) * 1e3) : 0;
+  }
+  audibleOutputState() {
+    return this.outputState;
+  }
+  setMuted(muted) {
+    this.muted = muted;
+    const context = this.playbackContext;
+    const gain = this.playbackGain;
+    if (context && gain) gain.gain.setValueAtTime(muted ? 0 : 1, context.currentTime);
+  }
+  isPlaying() {
+    return this.activeSources.size > 0;
+  }
+  async resume() {
+    const context = this.playbackContext ??= new AudioContext({ sampleRate: AUDIO_SAMPLE_RATE });
+    this.publish("pending");
+    try {
+      await context.resume();
+      this.publish(this.activeSources.size > 0 ? "audible" : "inactive");
+      return true;
+    } catch {
+      this.publish("blocked");
+      return false;
+    }
+  }
+  dispose() {
+    this.captureProcessor?.disconnect();
+    this.captureSource?.disconnect();
+    void this.captureContext?.close();
+    this.captureProcessor = null;
+    this.captureSource = null;
+    this.captureContext = null;
+    this.stopPlayback();
+    this.playbackGain?.disconnect();
+    void this.playbackContext?.close();
+    this.playbackGain = null;
+    this.playbackContext = null;
+  }
+  outputNode(context) {
+    if (!this.playbackGain) {
+      this.playbackGain = context.createGain();
+      this.playbackGain.gain.value = this.muted ? 0 : 1;
+      this.playbackGain.connect(context.destination);
+    }
+    return this.playbackGain;
+  }
+  publish(state) {
+    if (state === this.outputState) return;
+    this.outputState = state;
+    this.options.onAudibleOutputState(state);
+  }
+};
+function send(websocket, event) {
+  if (websocket.readyState !== WebSocket.OPEN) return;
+  websocket.send(JSON.stringify(event));
+}
+function delegationRequest(argumentsJson) {
+  try {
+    const parsed = JSON.parse(argumentsJson);
+    if (isRecord(parsed) && typeof parsed.request === "string" && parsed.request.trim()) {
+      return parsed.request.trim();
+    }
+  } catch {
+  }
+  return argumentsJson.trim() || "Continue the user's current request.";
+}
+function providerEventId(event) {
+  const raw = isRecord(event.raw) ? event.raw : null;
+  return stringValue(event.eventId) ?? stringValue(raw?.event_id) ?? stringValue(raw?.id) ?? crypto.randomUUID();
+}
+function encodePcm16(samples) {
+  const bytes = new Uint8Array(samples.length * 2);
+  const view = new DataView(bytes.buffer);
+  for (let index = 0; index < samples.length; index += 1) {
+    const sample = Math.max(-1, Math.min(1, samples[index] ?? 0));
+    view.setInt16(index * 2, sample < 0 ? sample * 32768 : sample * 32767, true);
+  }
+  let binary = "";
+  for (let start = 0; start < bytes.length; start += 32768) {
+    binary += String.fromCharCode(...bytes.subarray(start, start + 32768));
+  }
+  return btoa(binary);
+}
+function decodePcm16(encoded) {
+  const binary = atob(encoded);
+  const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const samples = new Float32Array(Math.floor(bytes.byteLength / 2));
+  for (let index = 0; index < samples.length; index += 1) {
+    samples[index] = view.getInt16(index * 2, true) / 32768;
+  }
+  return samples;
+}
+function resample(input, inputRate, outputRate) {
+  if (inputRate === outputRate) return input;
+  const ratio = inputRate / outputRate;
+  const output = new Float32Array(Math.round(input.length / ratio));
+  for (let index = 0; index < output.length; index += 1) {
+    const source = index * ratio;
+    const floor = Math.floor(source);
+    const ceil = Math.min(floor + 1, input.length - 1);
+    const fraction = source - floor;
+    output[index] = (input[floor] ?? 0) * (1 - fraction) + (input[ceil] ?? 0) * fraction;
+  }
+  return output;
+}
+async function waitForWebSocketOpen(websocket, signal) {
+  if (websocket.readyState === WebSocket.OPEN) return;
+  await new Promise((resolve, reject) => {
+    const cleanup = () => {
+      websocket.removeEventListener("open", onOpen);
+      websocket.removeEventListener("error", onError);
+      websocket.removeEventListener("close", onClose);
+      signal.removeEventListener("abort", onAbort);
+    };
+    const onOpen = () => {
+      cleanup();
+      resolve();
+    };
+    const onError = () => {
+      cleanup();
+      reject(new Error("AI Gateway realtime WebSocket failed to open"));
+    };
+    const onClose = () => {
+      cleanup();
+      reject(new Error("AI Gateway realtime WebSocket closed before opening"));
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+    };
+    websocket.addEventListener("open", onOpen, { once: true });
+    websocket.addEventListener("error", onError, { once: true });
+    websocket.addEventListener("close", onClose, { once: true });
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+  return typeof value === "string" ? value : null;
+}
+function throwIfAborted(signal) {
+  if (signal.aborted) throw signal.reason ?? new DOMException("Aborted", "AbortError");
+}
+
+export {
+  createGatewayRealtimeTransportStarter
+};
+//# sourceMappingURL=chunk-DXDL7EEW.js.map