@gravity-rail/sdk 0.5.1 → 0.7.0

package/dist/oauth-client.js

@@ -0,0 +1,48 @@
+// src/oauth-client/pkce.ts
+function bytesToBase64Url(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 1) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function generateOAuthState() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return bytesToBase64Url(bytes);
+}
+function generateCodeVerifier() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return bytesToBase64Url(bytes);
+}
+async function generateCodeChallenge(codeVerifier) {
+  const data = new TextEncoder().encode(codeVerifier);
+  const digest = await crypto.subtle.digest("SHA-256", data);
+  return bytesToBase64Url(new Uint8Array(digest));
+}
+function buildAuthorizationUrl(params) {
+  const search = new URLSearchParams({
+    response_type: "code",
+    client_id: params.clientId,
+    redirect_uri: params.redirectUri,
+    scope: params.scopes.join(" "),
+    state: params.state,
+    code_challenge: params.codeChallenge,
+    code_challenge_method: "S256"
+  });
+  if (params.workspaceUuid) {
+    search.set("workspace", params.workspaceUuid);
+  }
+  if (params.orgSlug) {
+    search.set("org", params.orgSlug);
+  }
+  return `${params.apiUrl}/api/v2/oauth/authorize?${search.toString()}`;
+}
+export {
+  buildAuthorizationUrl,
+  generateCodeChallenge,
+  generateCodeVerifier,
+  generateOAuthState
+};
+//# sourceMappingURL=oauth-client.js.map

package/dist/oauth-client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/oauth-client/pkce.ts"],"sourcesContent":["function bytesToBase64Url(bytes: Uint8Array): string {\n   let binary = '';\n   for (let i = 0; i < bytes.length; i += 1) {\n      binary += String.fromCharCode(bytes[i]);\n   }\n   return btoa(binary).replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=+$/, '');\n}\n\nexport function generateOAuthState(): string {\n   const bytes = new Uint8Array(32);\n   crypto.getRandomValues(bytes);\n   return bytesToBase64Url(bytes);\n}\n\nexport function generateCodeVerifier(): string {\n   const bytes = new Uint8Array(32);\n   crypto.getRandomValues(bytes);\n   return bytesToBase64Url(bytes);\n}\n\nexport async function generateCodeChallenge(codeVerifier: string): Promise<string> {\n   const data = new TextEncoder().encode(codeVerifier);\n   const digest = await crypto.subtle.digest('SHA-256', data);\n   return bytesToBase64Url(new Uint8Array(digest));\n}\n\nexport function buildAuthorizationUrl(params: {\n   apiUrl: string;\n   clientId: string;\n   redirectUri: string;\n   scopes: string[];\n   state: string;\n   codeChallenge: string;\n   workspaceUuid?: string;\n   orgSlug?: string;\n}): string {\n   const search = new URLSearchParams({\n      response_type: 'code',\n      client_id: params.clientId,\n      redirect_uri: params.redirectUri,\n      scope: params.scopes.join(' '),\n      state: params.state,\n      code_challenge: params.codeChallenge,\n      code_challenge_method: 'S256',\n   });\n\n   if (params.workspaceUuid) {\n      search.set('workspace', params.workspaceUuid);\n   }\n   if (params.orgSlug) {\n      search.set('org', params.orgSlug);\n   }\n\n   return `${params.apiUrl}/api/v2/oauth/authorize?${search.toString()}`;\n}\n"],"mappings":";AAAA,SAAS,iBAAiB,OAA2B;AAClD,MAAI,SAAS;AACb,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,GAAG;AACvC,cAAU,OAAO,aAAa,MAAM,CAAC,CAAC;AAAA,EACzC;AACA,SAAO,KAAK,MAAM,EAAE,QAAQ,OAAO,GAAG,EAAE,QAAQ,OAAO,GAAG,EAAE,QAAQ,OAAO,EAAE;AAChF;AAEO,SAAS,qBAA6B;AAC1C,QAAM,QAAQ,IAAI,WAAW,EAAE;AAC/B,SAAO,gBAAgB,KAAK;AAC5B,SAAO,iBAAiB,KAAK;AAChC;AAEO,SAAS,uBAA+B;AAC5C,QAAM,QAAQ,IAAI,WAAW,EAAE;AAC/B,SAAO,gBAAgB,KAAK;AAC5B,SAAO,iBAAiB,KAAK;AAChC;AAEA,eAAsB,sBAAsB,cAAuC;AAChF,QAAM,OAAO,IAAI,YAAY,EAAE,OAAO,YAAY;AAClD,QAAM,SAAS,MAAM,OAAO,OAAO,OAAO,WAAW,IAAI;AACzD,SAAO,iBAAiB,IAAI,WAAW,MAAM,CAAC;AACjD;AAEO,SAAS,sBAAsB,QAS3B;AACR,QAAM,SAAS,IAAI,gBAAgB;AAAA,IAChC,eAAe;AAAA,IACf,WAAW,OAAO;AAAA,IAClB,cAAc,OAAO;AAAA,IACrB,OAAO,OAAO,OAAO,KAAK,GAAG;AAAA,IAC7B,OAAO,OAAO;AAAA,IACd,gBAAgB,OAAO;AAAA,IACvB,uBAAuB;AAAA,EAC1B,CAAC;AAED,MAAI,OAAO,eAAe;AACvB,WAAO,IAAI,aAAa,OAAO,aAAa;AAAA,EAC/C;AACA,MAAI,OAAO,SAAS;AACjB,WAAO,IAAI,OAAO,OAAO,OAAO;AAAA,EACnC;AAEA,SAAO,GAAG,OAAO,MAAM,2BAA2B,OAAO,SAAS,CAAC;AACtE;","names":[]}

package/dist/realtime.cjs

@@ -0,0 +1,637 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/realtime/index.ts
+var realtime_exports = {};
+__export(realtime_exports, {
+  OperatorSessionClient: () => OperatorSessionClient,
+  WorkspaceRealtimeClient: () => WorkspaceRealtimeClient,
+  buildWorkspaceWsUrl: () => buildWorkspaceWsUrl,
+  initWorkspaceSocket: () => initWorkspaceSocket,
+  isActiveCallPhase: () => isActiveCallPhase,
+  isWorkspaceSocketConnected: () => isWorkspaceSocketConnected,
+  onWorkspaceSocketConnection: () => onWorkspaceSocketConnection,
+  subscribeWorkspaceChannel: () => subscribeWorkspaceChannel
+});
+module.exports = __toCommonJS(realtime_exports);
+
+// src/realtime/types.ts
+function isActiveCallPhase(phase) {
+  return phase === "dialing" || phase === "live" || phase === "onHold";
+}
+
+// src/realtime/workspace-client.ts
+var HEARTBEAT_INTERVAL_MS = 3e4;
+var RECONNECT_DELAY_MS = 3e3;
+var MAX_RECONNECT_ATTEMPTS = 5;
+var CLOSE_DELAY_MS = 1e3;
+function createSocketState() {
+  return {
+    ws: null,
+    connected: false,
+    connecting: false,
+    listeners: /* @__PURE__ */ new Map(),
+    subscribedChannels: /* @__PURE__ */ new Set(),
+    reconnectAttempts: 0,
+    reconnectTimer: null,
+    heartbeatTimer: null,
+    closeTimer: null,
+    intentionalClose: false
+  };
+}
+function buildWorkspaceWsUrl(session) {
+  const isSsl = session.apiUrl.startsWith("https");
+  const host = session.apiUrl.replace(/^https?:\/\//, "");
+  return `${isSsl ? "wss" : "ws"}://${host}/api/v2/w/${session.workspaceUuid}/ws/realtime`;
+}
+var WorkspaceRealtimeClient = class {
+  session = null;
+  getSessionFn;
+  state = createSocketState();
+  connectionListeners = /* @__PURE__ */ new Set();
+  constructor(config) {
+    if (typeof config === "function") {
+      this.getSessionFn = config;
+    } else {
+      this.getSessionFn = null;
+      if (config) {
+        this.session = config;
+      }
+    }
+  }
+  resolveSession() {
+    return this.session ?? this.getSessionFn?.() ?? null;
+  }
+  notifyConnectionListeners() {
+    for (const listener of this.connectionListeners) {
+      listener(this.state.connected);
+    }
+  }
+  clearCloseTimer() {
+    if (this.state.closeTimer) {
+      clearTimeout(this.state.closeTimer);
+      this.state.closeTimer = null;
+    }
+  }
+  setSession(session) {
+    const changed = this.session?.accessToken !== session.accessToken || this.session?.workspaceUuid !== session.workspaceUuid || this.session?.apiUrl !== session.apiUrl;
+    this.session = session;
+    if (changed && this.state.ws) {
+      this.closeConnection();
+    }
+    if (this.state.listeners.size > 0) {
+      this.ensureConnection();
+    }
+  }
+  subscribe(channel, listener) {
+    this.clearCloseTimer();
+    let listeners = this.state.listeners.get(channel);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      this.state.listeners.set(channel, listeners);
+    }
+    listeners.add(listener);
+    this.ensureConnection();
+    if (this.state.connected && this.state.ws?.readyState === WebSocket.OPEN && !this.state.subscribedChannels.has(channel)) {
+      this.state.ws.send(JSON.stringify({ type: "subscribe", channels: [channel] }));
+    }
+    return () => {
+      const channelListeners = this.state.listeners.get(channel);
+      channelListeners?.delete(listener);
+      if (channelListeners && channelListeners.size === 0) {
+        this.state.listeners.delete(channel);
+        this.state.subscribedChannels.delete(channel);
+        if (this.state.connected && this.state.ws?.readyState === WebSocket.OPEN) {
+          this.state.ws.send(JSON.stringify({ type: "unsubscribe", channels: [channel] }));
+        }
+      }
+      if (this.state.listeners.size === 0) {
+        this.state.closeTimer = setTimeout(() => {
+          if (this.state.listeners.size === 0) {
+            this.closeConnection();
+          }
+        }, CLOSE_DELAY_MS);
+      }
+    };
+  }
+  send(channel, data) {
+    if (!this.state.connected || !this.state.ws) return;
+    this.state.ws.send(JSON.stringify({ type: "message", channel, data }));
+  }
+  onConnection(listener) {
+    this.connectionListeners.add(listener);
+    listener(this.state.connected);
+    return () => {
+      this.connectionListeners.delete(listener);
+    };
+  }
+  isConnected() {
+    return this.state.connected;
+  }
+  ensureConnection() {
+    const session = this.resolveSession();
+    if (!session) return;
+    if (typeof window === "undefined" || typeof WebSocket === "undefined") return;
+    if (this.state.ws || this.state.connecting) return;
+    this.clearCloseTimer();
+    this.state.connecting = true;
+    this.state.intentionalClose = false;
+    const ws = new WebSocket(buildWorkspaceWsUrl(session));
+    ws.onopen = () => {
+      ws.send(JSON.stringify({ type: "login", token: session.accessToken }));
+    };
+    ws.onmessage = (event) => {
+      try {
+        const msg = JSON.parse(String(event.data));
+        if (msg.type === "protocol.init" && !this.state.connected) {
+          this.state.connected = true;
+          this.state.connecting = false;
+          this.state.reconnectAttempts = 0;
+          if (this.state.heartbeatTimer) clearInterval(this.state.heartbeatTimer);
+          this.state.heartbeatTimer = setInterval(() => {
+            if (this.state.ws?.readyState === WebSocket.OPEN) {
+              this.state.ws.send(JSON.stringify({ type: "heartbeat" }));
+            }
+          }, HEARTBEAT_INTERVAL_MS);
+          if (this.state.listeners.size > 0) {
+            ws.send(
+              JSON.stringify({
+                type: "subscribe",
+                channels: Array.from(this.state.listeners.keys())
+              })
+            );
+          }
+          this.notifyConnectionListeners();
+          return;
+        }
+        if (msg.type === "subscribed" && Array.isArray(msg.channels)) {
+          for (const ch of msg.channels) {
+            this.state.subscribedChannels.add(ch);
+          }
+          return;
+        }
+        if (msg.type === "unsubscribed" && Array.isArray(msg.channels)) {
+          for (const ch of msg.channels) {
+            this.state.subscribedChannels.delete(ch);
+          }
+          return;
+        }
+        if (msg.type === "event" && msg.channel && msg.event) {
+          const channelListeners = this.state.listeners.get(msg.channel);
+          if (channelListeners) {
+            for (const channelListener of channelListeners) {
+              try {
+                channelListener(msg.event);
+              } catch (err) {
+                console.error("Channel listener error:", err);
+              }
+            }
+          }
+        }
+      } catch {
+      }
+    };
+    ws.onclose = () => {
+      this.state.connected = false;
+      this.state.connecting = false;
+      this.state.ws = null;
+      this.state.subscribedChannels.clear();
+      if (this.state.heartbeatTimer) {
+        clearInterval(this.state.heartbeatTimer);
+        this.state.heartbeatTimer = null;
+      }
+      this.notifyConnectionListeners();
+      if (!this.state.intentionalClose && this.state.listeners.size > 0 && this.state.reconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
+        this.state.reconnectAttempts += 1;
+        this.state.reconnectTimer = setTimeout(() => {
+          this.ensureConnection();
+        }, RECONNECT_DELAY_MS * this.state.reconnectAttempts);
+      }
+    };
+    ws.onerror = () => {
+    };
+    this.state.ws = ws;
+  }
+  closeConnection() {
+    this.state.intentionalClose = true;
+    this.clearCloseTimer();
+    if (this.state.reconnectTimer) {
+      clearTimeout(this.state.reconnectTimer);
+      this.state.reconnectTimer = null;
+    }
+    if (this.state.heartbeatTimer) {
+      clearInterval(this.state.heartbeatTimer);
+      this.state.heartbeatTimer = null;
+    }
+    this.state.ws?.close();
+    this.state.ws = null;
+    this.state.connected = false;
+    this.state.connecting = false;
+    this.state.subscribedChannels.clear();
+    this.notifyConnectionListeners();
+  }
+};
+var defaultClient = new WorkspaceRealtimeClient();
+function initWorkspaceSocket(session) {
+  defaultClient.setSession(session);
+}
+function subscribeWorkspaceChannel(channel, listener) {
+  return defaultClient.subscribe(channel, listener);
+}
+function onWorkspaceSocketConnection(listener) {
+  return defaultClient.onConnection(listener);
+}
+function isWorkspaceSocketConnected() {
+  return defaultClient.isConnected();
+}
+
+// src/audio/pcm.ts
+var SERVER_SAMPLE_RATE = 24e3;
+var TARGET_SAMPLE_RATE = 24e3;
+function float32ArrayToBase64(float32Array) {
+  const int16Array = new Int16Array(float32Array.length);
+  for (let i = 0; i < float32Array.length; i += 1) {
+    const sample = Math.max(-1, Math.min(1, float32Array[i]));
+    int16Array[i] = Math.round(sample * 32767);
+  }
+  const uint8Array = new Uint8Array(int16Array.buffer);
+  let binaryString = "";
+  for (let i = 0; i < uint8Array.length; i += 1) {
+    binaryString += String.fromCharCode(uint8Array[i]);
+  }
+  return btoa(binaryString);
+}
+function base64ToFloat32Array(base64) {
+  const binaryString = atob(base64);
+  const len = binaryString.length / 2;
+  const float32Array = new Float32Array(len);
+  for (let i = 0; i < len; i += 1) {
+    const lo = binaryString.charCodeAt(i * 2);
+    const hi = binaryString.charCodeAt(i * 2 + 1);
+    let int16 = hi << 8 | lo;
+    if (int16 >= 32768) int16 -= 65536;
+    float32Array[i] = int16 / 32768;
+  }
+  return float32Array;
+}
+
+// src/realtime/operator-session-client.ts
+var OperatorSessionClient = class {
+  constructor(handlers = {}) {
+    this.handlers = handlers;
+  }
+  ws = null;
+  audioContext = null;
+  mediaStream = null;
+  processor = null;
+  sessionState = "idle";
+  callPhase = "idle";
+  nextPlaybackTime = 0;
+  playbackSources = [];
+  micActive = false;
+  onHold = false;
+  receivedRemoteAudio = false;
+  heartbeatTimer = null;
+  sessionCloseNotified = false;
+  intentionalDisconnect = false;
+  getSessionState() {
+    return this.sessionState;
+  }
+  getCallPhase() {
+    return this.callPhase;
+  }
+  setSessionState(next) {
+    this.sessionState = next;
+    this.handlers.onSessionStateChange?.(next);
+  }
+  setCallPhase(next) {
+    this.callPhase = next;
+    this.handlers.onCallPhaseChange?.(next);
+  }
+  notifySessionClosed(reason) {
+    if (this.sessionCloseNotified) return;
+    this.sessionCloseNotified = true;
+    this.handlers.onSessionClosed?.(reason);
+  }
+  async connect(session, chatId) {
+    if (typeof window === "undefined" || typeof WebSocket === "undefined") {
+      throw new Error("Operator session WebSocket is not available in this environment");
+    }
+    await this.disconnect();
+    this.sessionCloseNotified = false;
+    this.setSessionState("connecting");
+    this.setCallPhase("connecting");
+    const isSsl = session.apiUrl.startsWith("https");
+    const host = session.apiUrl.replace(/^https?:\/\//, "");
+    const wsUrl = `${isSsl ? "wss" : "ws"}://${host}/api/v2/w/${session.workspaceUuid}/operator/chats/${chatId}/session-ws`;
+    await new Promise((resolve, reject) => {
+      const ws = new WebSocket(wsUrl);
+      this.ws = ws;
+      ws.onopen = () => {
+        ws.send(JSON.stringify({ type: "login", token: session.accessToken }));
+      };
+      ws.onmessage = (event) => {
+        try {
+          const msg = JSON.parse(String(event.data));
+          this.handleMessage(msg, resolve, reject);
+        } catch {
+        }
+      };
+      ws.onerror = () => {
+        const message = "Operator session WebSocket error";
+        const wasConnecting = this.sessionState === "connecting";
+        this.setSessionState("error");
+        if (wasConnecting) {
+          this.setCallPhase("idle");
+          reject(new Error(message));
+        } else {
+          this.setCallPhase("failed");
+          this.handlers.onError?.(message);
+        }
+      };
+      ws.onclose = () => {
+        this.clearHeartbeat();
+        this.stopMicrophone();
+        this.stopPlayback();
+        const wasConnected = this.sessionState === "connected";
+        this.setSessionState("idle");
+        this.setCallPhase("idle");
+        if (wasConnected && !this.intentionalDisconnect) {
+          this.notifySessionClosed("disconnect");
+        }
+        this.intentionalDisconnect = false;
+      };
+    });
+  }
+  handleMessage(msg, resolveLogin, rejectLogin) {
+    if (msg.type === "RUN_ERROR" || msg.type === "error") {
+      const message = msg.message ?? "Operator session error";
+      if (this.sessionState === "connecting") {
+        this.setSessionState("error");
+        rejectLogin(new Error(message));
+      } else {
+        this.setCallPhase("failed");
+        this.handlers.onError?.(message);
+      }
+      return;
+    }
+    if (msg.type === "protocol.init" && this.sessionState === "connecting") {
+      return;
+    }
+    if (msg.type === "CUSTOM" && msg.name === "operator.session_ready") {
+      this.setSessionState("connected");
+      this.setCallPhase("ready");
+      this.startHeartbeat();
+      resolveLogin();
+      return;
+    }
+    if (msg.type === "event" && msg.event) {
+      if (this.handleRemoteVoiceAudio(msg.event)) {
+        return;
+      }
+      this.handlers.onAguiEvent?.(msg.event);
+      return;
+    }
+    if (msg.type === "CUSTOM" && msg.name === "operator.call.started") {
+      this.receivedRemoteAudio = false;
+      this.setCallPhase("dialing");
+      return;
+    }
+    if (msg.type === "CUSTOM" && msg.name === "operator.call.ended") {
+      this.onHold = false;
+      this.receivedRemoteAudio = false;
+      this.stopMicrophone();
+      this.stopPlayback();
+      const endSession = msg.value?.end_session === true;
+      const reason = typeof msg.value?.reason === "string" ? msg.value.reason : void 0;
+      if (endSession) {
+        this.setCallPhase("idle");
+        this.notifySessionClosed(reason ?? "peer_hangup");
+      } else {
+        this.setCallPhase("ready");
+      }
+      return;
+    }
+  }
+  /** Play callee PCM from wrapped chat-stream events; returns true if handled. */
+  handleRemoteVoiceAudio(event) {
+    if (event.type !== "CUSTOM" || event.name !== "voice.audio") {
+      return false;
+    }
+    if (this.onHold) return true;
+    const value = event.value;
+    if (!value || typeof value !== "object") return true;
+    const data = value.data;
+    if (typeof data !== "string" || !data) return true;
+    if (!this.receivedRemoteAudio && (this.callPhase === "dialing" || this.callPhase === "live")) {
+      this.receivedRemoteAudio = true;
+      this.setCallPhase("live");
+    }
+    void this.playPcm16(base64ToFloat32Array(data));
+    return true;
+  }
+  startHeartbeat() {
+    this.clearHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(JSON.stringify({ type: "heartbeat" }));
+      }
+    }, 3e4);
+  }
+  clearHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  sendCustom(name, value = {}) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("Operator session WebSocket is not connected");
+    }
+    this.ws.send(JSON.stringify({ type: "CUSTOM", name, value }));
+  }
+  async placeCall(memberId) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("Operator session WebSocket is not connected");
+    }
+    if (this.sessionState !== "connected") {
+      throw new Error("Operator session is not ready");
+    }
+    await this.startMicrophone();
+    this.sendCustom("operator.call.place", { member_id: memberId });
+  }
+  hangUp() {
+    try {
+      this.sendCustom("operator.call.hangup");
+    } catch {
+    }
+    this.onHold = false;
+    this.receivedRemoteAudio = false;
+  }
+  forwardCall(phoneNumber) {
+    this.receivedRemoteAudio = false;
+    this.setCallPhase("dialing");
+    this.sendCustom("operator.call.forward", { phone_number: phoneNumber });
+  }
+  setHold(onHold) {
+    this.onHold = onHold;
+    this.sendCustom("operator.call.hold", { on_hold: onHold });
+    if (this.callPhase === "live" || this.callPhase === "onHold") {
+      this.setCallPhase(onHold ? "onHold" : "live");
+    }
+    if (onHold) {
+      this.stopPlayback();
+    }
+  }
+  async startMicrophone() {
+    if (typeof window === "undefined") return;
+    if (!navigator.mediaDevices?.getUserMedia) {
+      throw new Error("Microphone not available in this browser");
+    }
+    if (this.micActive) return;
+    this.mediaStream = await navigator.mediaDevices.getUserMedia({
+      audio: {
+        echoCancellation: true,
+        noiseSuppression: true,
+        autoGainControl: true
+      }
+    });
+    const Ctx = window.AudioContext ?? window.webkitAudioContext;
+    if (!Ctx) throw new Error("Web Audio not supported");
+    this.audioContext = new Ctx();
+    if (this.audioContext.state === "suspended") {
+      await this.audioContext.resume();
+    }
+    const source = this.audioContext.createMediaStreamSource(this.mediaStream);
+    const processor = this.audioContext.createScriptProcessor(4096, 1, 1);
+    this.processor = processor;
+    processor.onaudioprocess = (event) => {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+      if (this.onHold) return;
+      if (this.callPhase !== "dialing" && this.callPhase !== "live" && this.callPhase !== "onHold") {
+        return;
+      }
+      const input = event.inputBuffer.getChannelData(0);
+      const copy = new Float32Array(input.length);
+      copy.set(input);
+      const sampleRate = this.audioContext?.sampleRate ?? TARGET_SAMPLE_RATE;
+      let pcm = copy;
+      if (sampleRate !== TARGET_SAMPLE_RATE) {
+        const ratio = sampleRate / TARGET_SAMPLE_RATE;
+        const newLen = Math.floor(copy.length / ratio);
+        const down = new Float32Array(newLen);
+        for (let i = 0; i < newLen; i += 1) {
+          down[i] = copy[Math.floor(i * ratio)];
+        }
+        pcm = down;
+      }
+      this.ws.send(
+        JSON.stringify({
+          type: "CUSTOM",
+          name: "voice.audio",
+          value: {
+            data: float32ArrayToBase64(pcm),
+            format: "pcm16",
+            sample_rate: TARGET_SAMPLE_RATE
+          }
+        })
+      );
+    };
+    source.connect(processor);
+    processor.connect(this.audioContext.destination);
+    this.micActive = true;
+  }
+  stopMicrophone() {
+    this.processor?.disconnect();
+    this.processor = null;
+    for (const track of this.mediaStream?.getTracks() ?? []) {
+      track.stop();
+    }
+    this.mediaStream = null;
+    this.micActive = false;
+  }
+  async playPcm16(samples) {
+    if (typeof window === "undefined") return;
+    const Ctx = window.AudioContext ?? window.webkitAudioContext;
+    if (!Ctx) return;
+    if (!this.audioContext || this.audioContext.state === "closed") {
+      this.audioContext = new Ctx();
+    }
+    if (this.audioContext.state === "suspended") {
+      await this.audioContext.resume();
+    }
+    const buffer = this.audioContext.createBuffer(1, samples.length, SERVER_SAMPLE_RATE);
+    buffer.copyToChannel(new Float32Array(samples), 0);
+    const source = this.audioContext.createBufferSource();
+    source.buffer = buffer;
+    source.connect(this.audioContext.destination);
+    const now = this.audioContext.currentTime;
+    const startAt = this.nextPlaybackTime < now + 0.02 ? now + 0.02 : this.nextPlaybackTime;
+    source.start(startAt);
+    this.nextPlaybackTime = startAt + buffer.duration;
+    this.playbackSources.push(source);
+    source.onended = () => {
+      const idx = this.playbackSources.indexOf(source);
+      if (idx >= 0) this.playbackSources.splice(idx, 1);
+    };
+  }
+  stopPlayback() {
+    for (const src of this.playbackSources) {
+      try {
+        src.stop();
+      } catch {
+      }
+    }
+    this.playbackSources = [];
+    this.nextPlaybackTime = 0;
+  }
+  async disconnect() {
+    this.intentionalDisconnect = true;
+    if (this.callPhase === "dialing" || this.callPhase === "live" || this.callPhase === "onHold") {
+      this.hangUp();
+    }
+    this.clearHeartbeat();
+    this.stopMicrophone();
+    this.stopPlayback();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    if (this.audioContext && this.audioContext.state !== "closed") {
+      await this.audioContext.close().catch(() => void 0);
+    }
+    this.audioContext = null;
+    this.onHold = false;
+    this.receivedRemoteAudio = false;
+    this.setSessionState("idle");
+    this.setCallPhase("idle");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OperatorSessionClient,
+  WorkspaceRealtimeClient,
+  buildWorkspaceWsUrl,
+  initWorkspaceSocket,
+  isActiveCallPhase,
+  isWorkspaceSocketConnected,
+  onWorkspaceSocketConnection,
+  subscribeWorkspaceChannel
+});
+//# sourceMappingURL=realtime.cjs.map