@estuary-ai/sdk 0.1.24 → 0.1.25

package/dist/index.mjs

@@ -1,7 +1,485 @@
-import { EstuaryError } from './chunk-W5QYPYX3.mjs';
-export { ErrorCode, EstuaryError } from './chunk-W5QYPYX3.mjs';
 import { io } from 'socket.io-client';
 
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/errors.ts
+var ErrorCode, EstuaryError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+      ErrorCode2["CONNECTION_FAILED"] = "CONNECTION_FAILED";
+      ErrorCode2["AUTH_FAILED"] = "AUTH_FAILED";
+      ErrorCode2["CONNECTION_TIMEOUT"] = "CONNECTION_TIMEOUT";
+      ErrorCode2["QUOTA_EXCEEDED"] = "QUOTA_EXCEEDED";
+      ErrorCode2["VOICE_NOT_SUPPORTED"] = "VOICE_NOT_SUPPORTED";
+      ErrorCode2["VOICE_ALREADY_ACTIVE"] = "VOICE_ALREADY_ACTIVE";
+      ErrorCode2["VOICE_NOT_ACTIVE"] = "VOICE_NOT_ACTIVE";
+      ErrorCode2["LIVEKIT_UNAVAILABLE"] = "LIVEKIT_UNAVAILABLE";
+      ErrorCode2["MICROPHONE_DENIED"] = "MICROPHONE_DENIED";
+      ErrorCode2["NOT_CONNECTED"] = "NOT_CONNECTED";
+      ErrorCode2["REST_ERROR"] = "REST_ERROR";
+      ErrorCode2["UNKNOWN"] = "UNKNOWN";
+      return ErrorCode2;
+    })(ErrorCode || {});
+    EstuaryError = class extends Error {
+      code;
+      details;
+      constructor(code, message, details) {
+        super(message);
+        this.name = "EstuaryError";
+        this.code = code;
+        this.details = details;
+      }
+    };
+  }
+});
+
+// src/audio/audio-utils.ts
+function resample(input, fromRate, toRate) {
+  const ratio = fromRate / toRate;
+  const outputLength = Math.round(input.length / ratio);
+  const output = new Float32Array(outputLength);
+  for (let i = 0; i < outputLength; i++) {
+    const srcIndex = i * ratio;
+    const low = Math.floor(srcIndex);
+    const high = Math.min(low + 1, input.length - 1);
+    const frac = srcIndex - low;
+    output[i] = input[low] * (1 - frac) + input[high] * frac;
+  }
+  return output;
+}
+function float32ToInt16(float32) {
+  const int16 = new Int16Array(float32.length);
+  for (let i = 0; i < float32.length; i++) {
+    const clamped = Math.max(-1, Math.min(1, float32[i]));
+    int16[i] = clamped < 0 ? clamped * 32768 : clamped * 32767;
+  }
+  return int16;
+}
+function uint8ArrayToBase64(bytes) {
+  if (typeof btoa === "function") {
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  }
+  return Buffer.from(bytes).toString("base64");
+}
+var init_audio_utils = __esm({
+  "src/audio/audio-utils.ts"() {
+  }
+});
+
+// src/voice/websocket-voice.ts
+var websocket_voice_exports = {};
+__export(websocket_voice_exports, {
+  WebSocketVoiceManager: () => WebSocketVoiceManager
+});
+var WebSocketVoiceManager;
+var init_websocket_voice = __esm({
+  "src/voice/websocket-voice.ts"() {
+    init_errors();
+    init_audio_utils();
+    WebSocketVoiceManager = class {
+      socketManager;
+      sampleRate;
+      logger;
+      audioContext = null;
+      mediaStream = null;
+      scriptProcessor = null;
+      sourceNode = null;
+      zeroGainNode = null;
+      _isMuted = false;
+      _isSuppressed = false;
+      _isActive = false;
+      constructor(socketManager, sampleRate, logger) {
+        this.socketManager = socketManager;
+        this.sampleRate = sampleRate;
+        this.logger = logger;
+      }
+      get isMuted() {
+        return this._isMuted;
+      }
+      get isActive() {
+        return this._isActive;
+      }
+      async start() {
+        if (this._isActive) {
+          throw new EstuaryError("VOICE_ALREADY_ACTIVE" /* VOICE_ALREADY_ACTIVE */, "Voice is already active");
+        }
+        if (typeof AudioContext === "undefined" && typeof globalThis.webkitAudioContext === "undefined") {
+          throw new EstuaryError("VOICE_NOT_SUPPORTED" /* VOICE_NOT_SUPPORTED */, "AudioContext is not available in this environment");
+        }
+        let stream;
+        try {
+          stream = await navigator.mediaDevices.getUserMedia({
+            audio: {
+              sampleRate: this.sampleRate,
+              channelCount: 1,
+              echoCancellation: true,
+              noiseSuppression: true,
+              autoGainControl: true
+            }
+          });
+        } catch (err) {
+          throw new EstuaryError(
+            "MICROPHONE_DENIED" /* MICROPHONE_DENIED */,
+            "Microphone access denied",
+            err
+          );
+        }
+        this.mediaStream = stream;
+        const AudioCtx = globalThis.AudioContext || globalThis.webkitAudioContext;
+        this.audioContext = new AudioCtx({ sampleRate: this.sampleRate });
+        this.sourceNode = this.audioContext.createMediaStreamSource(stream);
+        this.scriptProcessor = this.audioContext.createScriptProcessor(4096, 1, 1);
+        const nativeRate = this.audioContext.sampleRate;
+        const targetRate = this.sampleRate;
+        this.scriptProcessor.onaudioprocess = (event) => {
+          if (this._isMuted || this._isSuppressed) return;
+          const inputData = event.inputBuffer.getChannelData(0);
+          let pcmFloat;
+          if (nativeRate !== targetRate) {
+            pcmFloat = resample(inputData, nativeRate, targetRate);
+          } else {
+            pcmFloat = inputData;
+          }
+          const pcm16 = float32ToInt16(pcmFloat);
+          const base64 = uint8ArrayToBase64(new Uint8Array(pcm16.buffer));
+          try {
+            this.socketManager.emitEvent("stream_audio", { audio: base64 });
+          } catch {
+          }
+        };
+        this.sourceNode.connect(this.scriptProcessor);
+        this.zeroGainNode = this.audioContext.createGain();
+        this.zeroGainNode.gain.value = 0;
+        this.scriptProcessor.connect(this.zeroGainNode);
+        this.zeroGainNode.connect(this.audioContext.destination);
+        this._isActive = true;
+        this.socketManager.emitEvent("start_voice");
+        this.logger.debug("WebSocket voice started");
+      }
+      async stop() {
+        if (!this._isActive) return;
+        try {
+          this.socketManager.emitEvent("stop_voice");
+        } catch {
+        }
+        this.cleanup();
+        this._isActive = false;
+        this._isMuted = false;
+        this._isSuppressed = false;
+        this.logger.debug("WebSocket voice stopped");
+      }
+      toggleMute() {
+        if (!this._isActive || !this.mediaStream) return;
+        this._isMuted = !this._isMuted;
+        for (const track of this.mediaStream.getAudioTracks()) {
+          track.enabled = !this._isMuted;
+        }
+        this.logger.debug("Mute toggled:", this._isMuted);
+      }
+      setSuppressed(suppressed) {
+        this._isSuppressed = suppressed;
+        this.logger.debug("Audio suppression:", suppressed ? "on" : "off");
+      }
+      dispose() {
+        this.cleanup();
+        this._isActive = false;
+        this._isMuted = false;
+        this._isSuppressed = false;
+      }
+      cleanup() {
+        if (this.scriptProcessor) {
+          this.scriptProcessor.onaudioprocess = null;
+          this.scriptProcessor.disconnect();
+          this.scriptProcessor = null;
+        }
+        if (this.zeroGainNode) {
+          this.zeroGainNode.disconnect();
+          this.zeroGainNode = null;
+        }
+        if (this.sourceNode) {
+          this.sourceNode.disconnect();
+          this.sourceNode = null;
+        }
+        if (this.mediaStream) {
+          for (const track of this.mediaStream.getTracks()) {
+            track.stop();
+          }
+          this.mediaStream = null;
+        }
+        if (this.audioContext) {
+          this.audioContext.close().catch(() => {
+          });
+          this.audioContext = null;
+        }
+      }
+    };
+  }
+});
+
+// src/voice/livekit-voice.ts
+var livekit_voice_exports = {};
+__export(livekit_voice_exports, {
+  LiveKitVoiceManager: () => LiveKitVoiceManager
+});
+var LiveKitVoiceManager;
+var init_livekit_voice = __esm({
+  "src/voice/livekit-voice.ts"() {
+    init_errors();
+    LiveKitVoiceManager = class {
+      socketManager;
+      logger;
+      room = null;
+      // livekit-client Room (dynamically imported)
+      _isMuted = false;
+      _isActive = false;
+      speakingStateCallback = null;
+      audioLevelCallback = null;
+      // Audio analyser (via livekit-client's createAudioAnalyser)
+      calculateVolume = null;
+      analyserCleanup = null;
+      audioLevelPollTimer = null;
+      _isBotSpeaking = false;
+      constructor(socketManager, logger) {
+        this.socketManager = socketManager;
+        this.logger = logger;
+      }
+      get isMuted() {
+        return this._isMuted;
+      }
+      get isActive() {
+        return this._isActive;
+      }
+      setSpeakingStateCallback(cb) {
+        this.speakingStateCallback = cb;
+      }
+      setAudioLevelCallback(cb) {
+        this.audioLevelCallback = cb;
+      }
+      async start() {
+        if (this._isActive) {
+          throw new EstuaryError("VOICE_ALREADY_ACTIVE" /* VOICE_ALREADY_ACTIVE */, "Voice is already active");
+        }
+        let Room;
+        let RoomEvent;
+        let Track;
+        try {
+          const lk = await import('livekit-client');
+          Room = lk.Room;
+          RoomEvent = lk.RoomEvent;
+          Track = lk.Track;
+        } catch {
+          throw new EstuaryError(
+            "LIVEKIT_UNAVAILABLE" /* LIVEKIT_UNAVAILABLE */,
+            "livekit-client package is not installed"
+          );
+        }
+        const tokenData = await this.requestToken();
+        this.room = new Room({
+          adaptiveStream: true,
+          dynacast: true,
+          audioCaptureDefaults: {
+            echoCancellation: true,
+            noiseSuppression: true,
+            autoGainControl: true
+          }
+        });
+        this.room.on(RoomEvent.TrackSubscribed, (track, _publication, participant) => {
+          if (track.kind === Track.Kind.Audio) {
+            this.logger.debug("Bot audio track subscribed from", participant.identity);
+            const audioElement = track.attach();
+            audioElement.autoplay = true;
+            audioElement.style.display = "none";
+            if (typeof document !== "undefined") {
+              document.body.appendChild(audioElement);
+            }
+            audioElement.play().catch(() => {
+            });
+            this.setupAnalyser(track);
+            if (this._isBotSpeaking) {
+              setTimeout(() => this.startAudioLevelPolling(), 50);
+            }
+          }
+        });
+        this.room.on(RoomEvent.TrackUnsubscribed, (track) => {
+          if (track.kind === Track.Kind.Audio) {
+            this.teardownAnalyser();
+            track.detach().forEach((el) => el.remove());
+          }
+        });
+        this.room.on(RoomEvent.Disconnected, () => {
+          this.logger.debug("LiveKit room disconnected");
+          this._isActive = false;
+          this._isBotSpeaking = false;
+          this.teardownAnalyser();
+          this.speakingStateCallback?.(false);
+        });
+        try {
+          await this.room.connect(tokenData.url, tokenData.token);
+          this.logger.debug("Connected to LiveKit room:", tokenData.room);
+        } catch (err) {
+          this.room = null;
+          const reason = err instanceof Error ? `: ${err.message}` : "";
+          throw new EstuaryError(
+            "CONNECTION_FAILED" /* CONNECTION_FAILED */,
+            `Failed to connect to LiveKit room${reason}`,
+            err
+          );
+        }
+        this.room.on(
+          RoomEvent.ParticipantAttributesChanged,
+          (changedAttributes, participant) => {
+            if (participant === this.room?.localParticipant) return;
+            const state = changedAttributes["estuary.state"];
+            if (state === "speaking") {
+              this._isBotSpeaking = true;
+              this.speakingStateCallback?.(true);
+              this.startAudioLevelPolling();
+            } else if (state === "idle") {
+              this._isBotSpeaking = false;
+              this.stopAudioLevelPolling();
+              this.speakingStateCallback?.(false);
+              this.audioLevelCallback?.(0);
+            }
+          }
+        );
+        try {
+          await this.room.localParticipant.setMicrophoneEnabled(true);
+          this.logger.debug("Microphone enabled");
+        } catch (err) {
+          this.room.disconnect();
+          this.room = null;
+          const reason = err instanceof Error ? `: ${err.message}` : "";
+          throw new EstuaryError(
+            "MICROPHONE_DENIED" /* MICROPHONE_DENIED */,
+            `Failed to enable microphone${reason}`,
+            err
+          );
+        }
+        this.socketManager.emitEvent("livekit_join", { room: tokenData.room });
+        this._isActive = true;
+        this.logger.debug("LiveKit voice started");
+      }
+      async stop() {
+        if (!this._isActive) return;
+        try {
+          this.socketManager.emitEvent("livekit_leave");
+        } catch {
+        }
+        this._isBotSpeaking = false;
+        this.teardownAnalyser();
+        this.speakingStateCallback?.(false);
+        if (this.room) {
+          for (const [, publication] of this.room.localParticipant.trackPublications) {
+            if (publication.track) {
+              publication.track.stop();
+            }
+          }
+          this.room.disconnect();
+          this.room = null;
+        }
+        this._isActive = false;
+        this._isMuted = false;
+        this.logger.debug("LiveKit voice stopped");
+      }
+      toggleMute() {
+        if (!this._isActive || !this.room) return;
+        this._isMuted = !this._isMuted;
+        this.room.localParticipant.setMicrophoneEnabled(!this._isMuted);
+        this.logger.debug("Mute toggled:", this._isMuted);
+      }
+      dispose() {
+        this.speakingStateCallback = null;
+        this.audioLevelCallback = null;
+        this._isBotSpeaking = false;
+        this.teardownAnalyser();
+        if (this.room) {
+          this.room.disconnect();
+          this.room = null;
+        }
+        this._isActive = false;
+        this._isMuted = false;
+      }
+      // ─── Audio Analyser (livekit-client built-in) ───────────────────
+      async setupAnalyser(track) {
+        this.teardownAnalyser();
+        try {
+          const { createAudioAnalyser } = await import('livekit-client');
+          const { analyser, calculateVolume, cleanup } = createAudioAnalyser(track, {
+            fftSize: 256,
+            smoothingTimeConstant: 0.3
+          });
+          if (analyser.context.state === "suspended") {
+            await analyser.context.resume();
+          }
+          this.calculateVolume = calculateVolume;
+          this.analyserCleanup = cleanup;
+          this.logger.debug("Audio analyser created for bot track");
+        } catch (err) {
+          this.logger.debug("Failed to create audio analyser:", err);
+        }
+      }
+      teardownAnalyser() {
+        this.stopAudioLevelPolling();
+        if (this.analyserCleanup) {
+          this.analyserCleanup().catch(() => {
+          });
+          this.analyserCleanup = null;
+        }
+        this.calculateVolume = null;
+      }
+      startAudioLevelPolling() {
+        if (this.audioLevelPollTimer !== null) return;
+        if (!this.calculateVolume) return;
+        this.audioLevelPollTimer = setInterval(() => {
+          if (!this.calculateVolume) {
+            this.stopAudioLevelPolling();
+            return;
+          }
+          const vol = this.calculateVolume();
+          this.audioLevelCallback?.(vol);
+        }, 33);
+      }
+      stopAudioLevelPolling() {
+        if (this.audioLevelPollTimer !== null) {
+          clearInterval(this.audioLevelPollTimer);
+          this.audioLevelPollTimer = null;
+        }
+      }
+      // ─── Private ────────────────────────────────────────────────────
+      requestToken() {
+        return new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => {
+            this.socketManager.onLiveKitToken(() => {
+            });
+            reject(new EstuaryError(
+              "CONNECTION_TIMEOUT" /* CONNECTION_TIMEOUT */,
+              "Timed out waiting for LiveKit token"
+            ));
+          }, 1e4);
+          this.socketManager.onLiveKitToken((data) => {
+            clearTimeout(timeout);
+            resolve(data);
+          });
+          this.socketManager.emitEvent("livekit_token");
+        });
+      }
+    };
+  }
+});
+
 // src/utils/event-emitter.ts
 var TypedEventEmitter = class {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -61,6 +539,9 @@ var TypedEventEmitter = class {
   }
 };
 
+// src/connection/socket-manager.ts
+init_errors();
+
 // src/types.ts
 var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
   ConnectionState2["Disconnected"] = "disconnected";
@@ -361,30 +842,31 @@ async function isLiveKitAvailable() {
 }
 async function createVoiceManager(transport, socketManager, sampleRate, logger) {
   if (transport === "websocket") {
-    const { WebSocketVoiceManager } = await import('./websocket-voice-6DMYBGHP.mjs');
-    return new WebSocketVoiceManager(socketManager, sampleRate, logger);
+    const { WebSocketVoiceManager: WebSocketVoiceManager2 } = await Promise.resolve().then(() => (init_websocket_voice(), websocket_voice_exports));
+    return new WebSocketVoiceManager2(socketManager, sampleRate, logger);
   }
   if (transport === "livekit") {
     if (await isLiveKitAvailable()) {
-      const { LiveKitVoiceManager } = await import('./livekit-voice-PV3TGH2Q.mjs');
-      return new LiveKitVoiceManager(socketManager, logger);
+      const { LiveKitVoiceManager: LiveKitVoiceManager2 } = await Promise.resolve().then(() => (init_livekit_voice(), livekit_voice_exports));
+      return new LiveKitVoiceManager2(socketManager, logger);
     }
     logger.warn("livekit-client not installed, falling back to WebSocket voice");
-    const { WebSocketVoiceManager } = await import('./websocket-voice-6DMYBGHP.mjs');
-    return new WebSocketVoiceManager(socketManager, sampleRate, logger);
+    const { WebSocketVoiceManager: WebSocketVoiceManager2 } = await Promise.resolve().then(() => (init_websocket_voice(), websocket_voice_exports));
+    return new WebSocketVoiceManager2(socketManager, sampleRate, logger);
   }
   if (transport === "auto") {
     if (await isLiveKitAvailable()) {
-      const { LiveKitVoiceManager } = await import('./livekit-voice-PV3TGH2Q.mjs');
-      return new LiveKitVoiceManager(socketManager, logger);
+      const { LiveKitVoiceManager: LiveKitVoiceManager2 } = await Promise.resolve().then(() => (init_livekit_voice(), livekit_voice_exports));
+      return new LiveKitVoiceManager2(socketManager, logger);
     }
-    const { WebSocketVoiceManager } = await import('./websocket-voice-6DMYBGHP.mjs');
-    return new WebSocketVoiceManager(socketManager, sampleRate, logger);
+    const { WebSocketVoiceManager: WebSocketVoiceManager2 } = await Promise.resolve().then(() => (init_websocket_voice(), websocket_voice_exports));
+    return new WebSocketVoiceManager2(socketManager, sampleRate, logger);
   }
   return null;
 }
 
 // src/rest/rest-client.ts
+init_errors();
 var DEFAULT_TIMEOUT_MS = 1e4;
 var RestClient = class {
   baseUrl;
@@ -705,6 +1187,9 @@ var Logger = class {
   }
 };
 
+// src/client.ts
+init_errors();
+
 // src/utils/action-parser.ts
 var ACTION_TAG_RE = /<action\s+([^>]*?)\/>/gi;
 var ATTR_RE = /(\w+)\s*=\s*"([^"]*)"|(\w+)\s*=\s*'([^']*)'/g;
@@ -1044,6 +1529,9 @@ var EstuaryClient = class extends TypedEventEmitter {
   }
 };
 
-export { ConnectionState, EstuaryClient, parseActions };
+// src/index.ts
+init_errors();
+
+export { ConnectionState, ErrorCode, EstuaryClient, EstuaryError, parseActions };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map