@estuary-ai/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1164 @@
+'use strict';
+
+var socket_ioClient = require('socket.io-client');
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+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 });
+};
+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/errors.ts
+exports.ErrorCode = void 0; exports.EstuaryError = void 0;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    exports.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;
+    })(exports.ErrorCode || {});
+    exports.EstuaryError = class extends Error {
+      code;
+      details;
+      constructor(code, message, details) {
+        super(message);
+        this.name = "EstuaryError";
+        this.code = code;
+        this.details = details;
+      }
+    };
+  }
+});
+
+// src/voice/websocket-voice.ts
+var websocket_voice_exports = {};
+__export(websocket_voice_exports, {
+  WebSocketVoiceManager: () => WebSocketVoiceManager
+});
+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 WebSocketVoiceManager;
+var init_websocket_voice = __esm({
+  "src/voice/websocket-voice.ts"() {
+    init_errors();
+    WebSocketVoiceManager = class {
+      socketManager;
+      sampleRate;
+      logger;
+      audioContext = null;
+      mediaStream = null;
+      scriptProcessor = null;
+      sourceNode = null;
+      _isMuted = 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 exports.EstuaryError("VOICE_ALREADY_ACTIVE" /* VOICE_ALREADY_ACTIVE */, "Voice is already active");
+        }
+        if (typeof AudioContext === "undefined" && typeof globalThis.webkitAudioContext === "undefined") {
+          throw new exports.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 }
+          });
+        } catch (err) {
+          throw new exports.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) 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.scriptProcessor.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.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);
+      }
+      dispose() {
+        this.cleanup();
+        this._isActive = false;
+        this._isMuted = false;
+      }
+      cleanup() {
+        if (this.scriptProcessor) {
+          this.scriptProcessor.onaudioprocess = null;
+          this.scriptProcessor.disconnect();
+          this.scriptProcessor = 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;
+      constructor(socketManager, logger) {
+        this.socketManager = socketManager;
+        this.logger = logger;
+      }
+      get isMuted() {
+        return this._isMuted;
+      }
+      get isActive() {
+        return this._isActive;
+      }
+      async start() {
+        if (this._isActive) {
+          throw new exports.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 exports.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.room.on(RoomEvent.TrackUnsubscribed, (track) => {
+          if (track.kind === Track.Kind.Audio) {
+            track.detach().forEach((el) => el.remove());
+          }
+        });
+        this.room.on(RoomEvent.Disconnected, () => {
+          this.logger.debug("LiveKit room disconnected");
+          this._isActive = false;
+        });
+        try {
+          await this.room.connect(tokenData.url, tokenData.token);
+          this.logger.debug("Connected to LiveKit room:", tokenData.room);
+        } catch (err) {
+          this.room = null;
+          throw new exports.EstuaryError(
+            "CONNECTION_FAILED" /* CONNECTION_FAILED */,
+            "Failed to connect to LiveKit room",
+            err
+          );
+        }
+        try {
+          await this.room.localParticipant.setMicrophoneEnabled(true);
+          this.logger.debug("Microphone enabled");
+        } catch (err) {
+          this.room.disconnect();
+          this.room = null;
+          throw new exports.EstuaryError(
+            "MICROPHONE_DENIED" /* MICROPHONE_DENIED */,
+            "Failed to enable microphone",
+            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 {
+        }
+        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() {
+        if (this.room) {
+          this.room.disconnect();
+          this.room = null;
+        }
+        this._isActive = false;
+        this._isMuted = false;
+      }
+      requestToken() {
+        return new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => {
+            this.socketManager.onLiveKitToken(() => {
+            });
+            reject(new exports.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
+  listeners = /* @__PURE__ */ new Map();
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  onceListeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(listener);
+    return this;
+  }
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+    this.onceListeners.get(event)?.delete(listener);
+    return this;
+  }
+  once(event, listener) {
+    if (!this.onceListeners.has(event)) {
+      this.onceListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.onceListeners.get(event).add(listener);
+    this.on(event, listener);
+    return this;
+  }
+  emit(event, ...args) {
+    const listeners = this.listeners.get(event);
+    if (!listeners || listeners.size === 0) return false;
+    for (const listener of listeners) {
+      try {
+        listener(...args);
+      } catch {
+      }
+    }
+    const onceSet = this.onceListeners.get(event);
+    if (onceSet) {
+      for (const listener of onceSet) {
+        this.listeners.get(event)?.delete(listener);
+      }
+      onceSet.clear();
+    }
+    return true;
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(event);
+      this.onceListeners.delete(event);
+    } else {
+      this.listeners.clear();
+      this.onceListeners.clear();
+    }
+    return this;
+  }
+  listenerCount(event) {
+    return this.listeners.get(event)?.size ?? 0;
+  }
+};
+
+// src/connection/socket-manager.ts
+init_errors();
+
+// src/types.ts
+var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
+  ConnectionState2["Disconnected"] = "disconnected";
+  ConnectionState2["Connecting"] = "connecting";
+  ConnectionState2["Connected"] = "connected";
+  ConnectionState2["Reconnecting"] = "reconnecting";
+  ConnectionState2["Error"] = "error";
+  return ConnectionState2;
+})(ConnectionState || {});
+function toSessionInfo(wire) {
+  return {
+    sessionId: wire.session_id,
+    conversationId: wire.conversation_id,
+    characterId: wire.character_id,
+    playerId: wire.player_id
+  };
+}
+function toBotResponse(wire) {
+  return {
+    text: wire.text,
+    isFinal: wire.is_final,
+    partial: wire.partial,
+    messageId: wire.message_id,
+    chunkIndex: wire.chunk_index,
+    isInterjection: wire.is_interjection
+  };
+}
+function toBotVoice(wire) {
+  return {
+    audio: wire.audio,
+    messageId: wire.message_id,
+    chunkIndex: wire.chunk_index,
+    isFinal: wire.is_final
+  };
+}
+function toSttResponse(wire) {
+  return {
+    text: wire.text,
+    isFinal: wire.is_final
+  };
+}
+function toInterruptData(wire) {
+  return {
+    messageId: wire.message_id,
+    reason: wire.reason,
+    interruptedAt: wire.interrupted_at
+  };
+}
+function toQuotaExceededData(wire) {
+  return {
+    message: wire.message,
+    current: wire.current,
+    limit: wire.limit,
+    remaining: wire.remaining,
+    tier: wire.tier
+  };
+}
+function toLiveKitTokenResponse(wire) {
+  return {
+    token: wire.token,
+    url: wire.url,
+    room: wire.room
+  };
+}
+function toCameraCaptureRequest(wire) {
+  return {
+    requestId: wire.request_id,
+    text: wire.text
+  };
+}
+function toMemoryUpdatedEvent(wire) {
+  return {
+    agentId: wire.agent_id,
+    playerId: wire.player_id,
+    memoriesExtracted: wire.memories_extracted,
+    factsExtracted: wire.facts_extracted,
+    conversationId: wire.conversation_id,
+    newMemories: wire.new_memories ?? [],
+    timestamp: wire.timestamp
+  };
+}
+
+// src/connection/socket-manager.ts
+var SocketManager = class extends TypedEventEmitter {
+  socket = null;
+  config;
+  logger;
+  connectionState = "disconnected" /* Disconnected */;
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  sessionInfo = null;
+  constructor(config, logger) {
+    super();
+    this.config = config;
+    this.logger = logger;
+  }
+  get state() {
+    return this.connectionState;
+  }
+  get session() {
+    return this.sessionInfo;
+  }
+  get isConnected() {
+    return this.connectionState === "connected" /* Connected */;
+  }
+  get rawSocket() {
+    return this.socket;
+  }
+  connect() {
+    return new Promise((resolve, reject) => {
+      if (this.socket?.connected) {
+        if (this.sessionInfo) {
+          resolve(this.sessionInfo);
+          return;
+        }
+      }
+      this.setConnectionState("connecting" /* Connecting */);
+      this.reconnectAttempt = 0;
+      const url = `${this.config.serverUrl}/sdk`;
+      this.logger.debug("Connecting to", url);
+      this.socket = socket_ioClient.io(url, {
+        transports: ["websocket"],
+        timeout: 1e4,
+        reconnection: false,
+        // We handle reconnection ourselves
+        path: "/socket.io/"
+      });
+      let settled = false;
+      const onConnect = () => {
+        this.logger.debug("Socket connected, authenticating...");
+        this.socket.emit("authenticate", {
+          api_key: this.config.apiKey,
+          character_id: this.config.characterId,
+          player_id: this.config.playerId,
+          audio_sample_rate: this.config.audioSampleRate ?? 16e3,
+          realtime_memory: this.config.realtimeMemory ?? false
+        });
+      };
+      const onSessionInfo = (data) => {
+        this.sessionInfo = toSessionInfo(data);
+        this.setConnectionState("connected" /* Connected */);
+        this.reconnectAttempt = 0;
+        this.logger.info("Connected, session:", this.sessionInfo.sessionId);
+        this.emit("connected", this.sessionInfo);
+        if (!settled) {
+          settled = true;
+          resolve(this.sessionInfo);
+        }
+      };
+      const onAuthError = (data) => {
+        this.logger.error("Auth error:", data.error);
+        this.setConnectionState("error" /* Error */);
+        this.emit("authError", data.error);
+        if (!settled) {
+          settled = true;
+          reject(new exports.EstuaryError("AUTH_FAILED" /* AUTH_FAILED */, data.error));
+        }
+      };
+      const onConnectError = (err) => {
+        this.logger.error("Connection error:", err.message);
+        if (!settled) {
+          settled = true;
+          this.setConnectionState("error" /* Error */);
+          reject(new exports.EstuaryError("CONNECTION_FAILED" /* CONNECTION_FAILED */, err.message));
+        } else {
+          this.handleDisconnect("connect_error");
+        }
+      };
+      const onDisconnect = (reason) => {
+        this.logger.info("Disconnected:", reason);
+        this.sessionInfo = null;
+        if (!settled) {
+          settled = true;
+          this.setConnectionState("disconnected" /* Disconnected */);
+          reject(new exports.EstuaryError("CONNECTION_FAILED" /* CONNECTION_FAILED */, `Disconnected: ${reason}`));
+        } else {
+          this.handleDisconnect(reason);
+        }
+      };
+      this.socket.on("connect", onConnect);
+      this.socket.on("session_info", onSessionInfo);
+      this.socket.on("auth_error", onAuthError);
+      this.socket.on("connect_error", onConnectError);
+      this.socket.on("disconnect", onDisconnect);
+      this.bindServerEvents();
+    });
+  }
+  disconnect() {
+    this.clearReconnectTimer();
+    this.sessionInfo = null;
+    if (this.socket) {
+      this.socket.removeAllListeners();
+      this.socket.disconnect();
+      this.socket = null;
+    }
+    this.setConnectionState("disconnected" /* Disconnected */);
+    this.emit("disconnected", "manual");
+  }
+  emitEvent(event, data) {
+    if (!this.socket?.connected) {
+      throw new exports.EstuaryError("NOT_CONNECTED" /* NOT_CONNECTED */, "Not connected to server");
+    }
+    this.socket.emit(event, data);
+  }
+  bindServerEvents() {
+    if (!this.socket) return;
+    this.socket.on("bot_response", (data) => {
+      this.emit("botResponse", toBotResponse(data));
+    });
+    this.socket.on("bot_voice", (data) => {
+      this.emit("botVoice", toBotVoice(data));
+    });
+    this.socket.on("stt_response", (data) => {
+      this.emit("sttResponse", toSttResponse(data));
+    });
+    this.socket.on("interrupt", (data) => {
+      this.emit("interrupt", toInterruptData(data));
+    });
+    this.socket.on("quota_exceeded", (data) => {
+      this.emit("quotaExceeded", toQuotaExceededData(data));
+    });
+    this.socket.on("camera_capture", (data) => {
+      this.emit("cameraCaptureRequest", toCameraCaptureRequest(data));
+    });
+    this.socket.on("error", (data) => {
+      this.emit("error", new exports.EstuaryError("UNKNOWN" /* UNKNOWN */, data.message));
+    });
+    this.socket.on("livekit_token", (data) => {
+      this._livekitTokenCallback?.(toLiveKitTokenResponse(data));
+    });
+    this.socket.on("livekit_ready", (data) => {
+      this.emit("livekitConnected", data.room);
+    });
+    this.socket.on("memory_updated", (data) => {
+      this.emit("memoryUpdated", toMemoryUpdatedEvent(data));
+    });
+  }
+  /** Register a callback for livekit_token events (used by LiveKitVoiceManager) */
+  onLiveKitToken(callback) {
+    this._livekitTokenCallback = callback;
+  }
+  handleDisconnect(reason) {
+    this.sessionInfo = null;
+    this.setConnectionState("disconnected" /* Disconnected */);
+    this.emit("disconnected", reason);
+    const autoReconnect = this.config.autoReconnect ?? true;
+    const maxAttempts = this.config.maxReconnectAttempts ?? 5;
+    if (autoReconnect && this.reconnectAttempt < maxAttempts) {
+      this.attemptReconnect();
+    }
+  }
+  attemptReconnect() {
+    const maxAttempts = this.config.maxReconnectAttempts ?? 5;
+    const delay = this.config.reconnectDelayMs ?? 2e3;
+    if (this.reconnectAttempt >= maxAttempts) {
+      this.logger.warn("Max reconnect attempts reached");
+      this.setConnectionState("error" /* Error */);
+      this.emit("error", new exports.EstuaryError(
+        "CONNECTION_FAILED" /* CONNECTION_FAILED */,
+        `Failed to reconnect after ${maxAttempts} attempts`
+      ));
+      return;
+    }
+    this.reconnectAttempt++;
+    this.setConnectionState("reconnecting" /* Reconnecting */);
+    this.emit("reconnecting", this.reconnectAttempt);
+    this.logger.info(`Reconnecting (attempt ${this.reconnectAttempt}/${maxAttempts})...`);
+    this.clearReconnectTimer();
+    this.reconnectTimer = setTimeout(() => {
+      this.connect().catch((err) => {
+        this.logger.error("Reconnect failed:", err.message);
+      });
+    }, delay * this.reconnectAttempt);
+  }
+  clearReconnectTimer() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  setConnectionState(state) {
+    if (this.connectionState !== state) {
+      this.connectionState = state;
+      this.emit("connectionStateChanged", state);
+    }
+  }
+};
+
+// src/voice/voice-manager.ts
+function createVoiceManager(transport, socketManager, sampleRate, logger) {
+  if (transport === "websocket") {
+    const { WebSocketVoiceManager: WebSocketVoiceManager2 } = (init_websocket_voice(), __toCommonJS(websocket_voice_exports));
+    return new WebSocketVoiceManager2(socketManager, sampleRate, logger);
+  }
+  if (transport === "livekit") {
+    try {
+      __require.resolve("livekit-client");
+      const { LiveKitVoiceManager: LiveKitVoiceManager2 } = (init_livekit_voice(), __toCommonJS(livekit_voice_exports));
+      return new LiveKitVoiceManager2(socketManager, logger);
+    } catch {
+      logger.warn("livekit-client not installed, falling back to WebSocket voice");
+      const { WebSocketVoiceManager: WebSocketVoiceManager2 } = (init_websocket_voice(), __toCommonJS(websocket_voice_exports));
+      return new WebSocketVoiceManager2(socketManager, sampleRate, logger);
+    }
+  }
+  if (transport === "auto") {
+    try {
+      __require.resolve("livekit-client");
+      const { LiveKitVoiceManager: LiveKitVoiceManager2 } = (init_livekit_voice(), __toCommonJS(livekit_voice_exports));
+      return new LiveKitVoiceManager2(socketManager, logger);
+    } catch {
+      const { WebSocketVoiceManager: WebSocketVoiceManager2 } = (init_websocket_voice(), __toCommonJS(websocket_voice_exports));
+      return new WebSocketVoiceManager2(socketManager, sampleRate, logger);
+    }
+  }
+  return null;
+}
+
+// src/rest/rest-client.ts
+init_errors();
+var RestClient = class {
+  baseUrl;
+  apiKey;
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.apiKey = apiKey;
+  }
+  async get(path, params) {
+    const url = this.buildUrl(path, params);
+    return this.request(url, { method: "GET" });
+  }
+  async post(path, body) {
+    const url = this.buildUrl(path);
+    const init = { method: "POST" };
+    if (body !== void 0) {
+      init.headers = { "Content-Type": "application/json" };
+      init.body = JSON.stringify(body);
+    }
+    return this.request(url, init);
+  }
+  async delete(path, params) {
+    const url = this.buildUrl(path, params);
+    return this.request(url, { method: "DELETE" });
+  }
+  dispose() {
+  }
+  buildUrl(path, params) {
+    const url = new URL(path, this.baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  async request(url, init) {
+    const headers = new Headers(init.headers);
+    headers.set("X-API-Key", this.apiKey);
+    const response = await fetch(url, { ...init, headers });
+    if (!response.ok) {
+      let detail;
+      try {
+        detail = await response.json();
+      } catch {
+        detail = await response.text().catch(() => null);
+      }
+      throw new exports.EstuaryError(
+        "REST_ERROR" /* REST_ERROR */,
+        `HTTP ${response.status}: ${response.statusText}`,
+        detail
+      );
+    }
+    return response.json();
+  }
+};
+
+// src/rest/memory-client.ts
+var MemoryClient = class {
+  rest;
+  basePath;
+  constructor(rest, agentId, playerId) {
+    this.rest = rest;
+    this.basePath = `/api/agents/${agentId}/players/${playerId}/memories`;
+  }
+  async getMemories(options) {
+    return this.rest.get(this.basePath, options);
+  }
+  async getTimeline(options) {
+    return this.rest.get(`${this.basePath}/timeline`, options);
+  }
+  async getStats() {
+    return this.rest.get(`${this.basePath}/stats`);
+  }
+  async getCoreFacts() {
+    return this.rest.get(`${this.basePath}/core-facts`);
+  }
+  async getGraph(options) {
+    const params = {};
+    if (options) {
+      if (options.includeEntities !== void 0) params.include_entities = options.includeEntities;
+      if (options.includeCharacterMemories !== void 0) params.include_character_memories = options.includeCharacterMemories;
+    }
+    return this.rest.get(`${this.basePath}/graph`, params);
+  }
+  async search(query, limit) {
+    return this.rest.get(`${this.basePath}/search`, { query, limit });
+  }
+  async deleteAll(confirm) {
+    return this.rest.delete(this.basePath, { confirm });
+  }
+  dispose() {
+  }
+};
+
+// src/audio/audio-player.ts
+var AudioPlayer = class {
+  sampleRate;
+  onEvent;
+  audioContext = null;
+  queue = [];
+  currentSource = null;
+  currentMessageId = null;
+  isPlaying = false;
+  constructor(sampleRate, onEvent) {
+    this.sampleRate = sampleRate;
+    this.onEvent = onEvent;
+  }
+  enqueue(voice) {
+    const ctx = this.getAudioContext();
+    if (!ctx) return;
+    const pcm16 = base64ToInt16Array(voice.audio);
+    const float32 = int16ToFloat32(pcm16);
+    const buffer = ctx.createBuffer(1, float32.length, this.sampleRate);
+    buffer.getChannelData(0).set(float32);
+    this.queue.push({ buffer, messageId: voice.messageId });
+    if (!this.isPlaying) {
+      this.playNext();
+    }
+  }
+  clear() {
+    this.queue.length = 0;
+    if (this.currentSource) {
+      try {
+        this.currentSource.onended = null;
+        this.currentSource.stop();
+      } catch {
+      }
+      this.currentSource = null;
+    }
+    this.isPlaying = false;
+    this.currentMessageId = null;
+  }
+  dispose() {
+    this.clear();
+    if (this.audioContext) {
+      this.audioContext.close().catch(() => {
+      });
+      this.audioContext = null;
+    }
+  }
+  getAudioContext() {
+    if (this.audioContext) return this.audioContext;
+    if (typeof AudioContext === "undefined" && typeof globalThis.webkitAudioContext === "undefined") {
+      return null;
+    }
+    const AudioCtx = globalThis.AudioContext || globalThis.webkitAudioContext;
+    this.audioContext = new AudioCtx({ sampleRate: this.sampleRate });
+    return this.audioContext;
+  }
+  playNext() {
+    const ctx = this.getAudioContext();
+    if (!ctx || this.queue.length === 0) {
+      if (this.isPlaying && this.currentMessageId) {
+        this.onEvent({ type: "complete", messageId: this.currentMessageId });
+      }
+      this.isPlaying = false;
+      this.currentMessageId = null;
+      return;
+    }
+    const { buffer, messageId } = this.queue.shift();
+    if (messageId !== this.currentMessageId) {
+      if (this.currentMessageId) {
+        this.onEvent({ type: "complete", messageId: this.currentMessageId });
+      }
+      this.currentMessageId = messageId;
+      this.onEvent({ type: "started", messageId });
+    }
+    this.isPlaying = true;
+    const source = ctx.createBufferSource();
+    source.buffer = buffer;
+    source.connect(ctx.destination);
+    this.currentSource = source;
+    source.onended = () => {
+      this.currentSource = null;
+      this.playNext();
+    };
+    source.start();
+  }
+};
+function base64ToInt16Array(base64) {
+  let bytes;
+  if (typeof atob === "function") {
+    const binary = atob(base64);
+    bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+  } else {
+    bytes = new Uint8Array(Buffer.from(base64, "base64"));
+  }
+  return new Int16Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 2);
+}
+function int16ToFloat32(int16) {
+  const float32 = new Float32Array(int16.length);
+  for (let i = 0; i < int16.length; i++) {
+    float32[i] = int16[i] / (int16[i] < 0 ? 32768 : 32767);
+  }
+  return float32;
+}
+
+// src/utils/logger.ts
+var Logger = class {
+  enabled;
+  constructor(debug = false) {
+    this.enabled = debug;
+  }
+  setDebug(enabled) {
+    this.enabled = enabled;
+  }
+  debug(...args) {
+    if (this.enabled) console.debug("[Estuary]", ...args);
+  }
+  info(...args) {
+    if (this.enabled) console.info("[Estuary]", ...args);
+  }
+  warn(...args) {
+    console.warn("[Estuary]", ...args);
+  }
+  error(...args) {
+    console.error("[Estuary]", ...args);
+  }
+};
+
+// src/client.ts
+init_errors();
+var DEFAULT_SAMPLE_RATE = 16e3;
+var EstuaryClient = class extends TypedEventEmitter {
+  config;
+  logger;
+  socketManager;
+  voiceManager = null;
+  audioPlayer = null;
+  _memory;
+  _sessionInfo = null;
+  constructor(config) {
+    super();
+    this.config = config;
+    this.logger = new Logger(config.debug ?? false);
+    this.socketManager = new SocketManager(config, this.logger);
+    this.forwardSocketEvents();
+    const restClient = new RestClient(config.serverUrl, config.apiKey);
+    this._memory = new MemoryClient(restClient, config.characterId, config.playerId);
+  }
+  /** Memory API client for querying memories, graphs, and facts */
+  get memory() {
+    return this._memory;
+  }
+  /** Current session info (null if not connected) */
+  get session() {
+    return this._sessionInfo;
+  }
+  /** Current connection state */
+  get connectionState() {
+    return this.socketManager.state;
+  }
+  /** Whether the client is connected and authenticated */
+  get isConnected() {
+    return this.socketManager.isConnected;
+  }
+  /** Connect to the Estuary server and authenticate */
+  async connect() {
+    this.logger.info("Connecting...");
+    const session = await this.socketManager.connect();
+    this._sessionInfo = session;
+    return session;
+  }
+  /** Disconnect from the server */
+  disconnect() {
+    this.logger.info("Disconnecting...");
+    this.stopVoice();
+    this.audioPlayer?.dispose();
+    this.audioPlayer = null;
+    this.socketManager.disconnect();
+    this._sessionInfo = null;
+  }
+  /** Send a text message to the character */
+  sendText(text, textOnly = false) {
+    this.ensureConnected();
+    this.socketManager.emitEvent("text", { text, textOnly });
+  }
+  /** Interrupt the current bot response */
+  interrupt(messageId) {
+    this.ensureConnected();
+    this.socketManager.emitEvent("client_interrupt", { message_id: messageId });
+    this.audioPlayer?.clear();
+  }
+  /** Send a camera image for vision processing */
+  sendCameraImage(imageBase64, mimeType, requestId, text) {
+    this.ensureConnected();
+    this.socketManager.emitEvent("camera_image", {
+      image: imageBase64,
+      mime_type: mimeType,
+      request_id: requestId,
+      text
+    });
+  }
+  /** Update session preferences */
+  updatePreferences(preferences) {
+    this.ensureConnected();
+    this.socketManager.emitEvent("update_preferences", preferences);
+  }
+  /** Notify server that audio playback completed for a message */
+  notifyAudioPlaybackComplete(messageId) {
+    this.ensureConnected();
+    this.socketManager.emitEvent("audio_playback_complete", { message_id: messageId });
+  }
+  // ─── Voice ───────────────────────────────────────────────────
+  /** Start voice input (requests microphone permission) */
+  async startVoice() {
+    this.ensureConnected();
+    if (this.voiceManager?.isActive) {
+      throw new exports.EstuaryError("VOICE_ALREADY_ACTIVE" /* VOICE_ALREADY_ACTIVE */, "Voice is already active");
+    }
+    const transport = this.config.voiceTransport ?? "auto";
+    const sampleRate = this.config.audioSampleRate ?? DEFAULT_SAMPLE_RATE;
+    this.voiceManager = createVoiceManager(transport, this.socketManager, sampleRate, this.logger);
+    if (!this.voiceManager) {
+      throw new exports.EstuaryError("VOICE_NOT_SUPPORTED" /* VOICE_NOT_SUPPORTED */, "No voice transport available");
+    }
+    if (!this.audioPlayer && typeof AudioContext !== "undefined") {
+      this.audioPlayer = new AudioPlayer(sampleRate, (event) => {
+        if (event.type === "started") {
+          this.emit("audioPlaybackStarted", event.messageId);
+        } else if (event.type === "complete") {
+          this.emit("audioPlaybackComplete", event.messageId);
+          this.notifyAudioPlaybackComplete(event.messageId);
+        }
+      });
+    }
+    await this.voiceManager.start();
+    this.emit("voiceStarted");
+  }
+  /** Stop voice input */
+  stopVoice() {
+    if (this.voiceManager?.isActive) {
+      this.voiceManager.stop();
+      this.voiceManager.dispose();
+      this.voiceManager = null;
+      this.emit("voiceStopped");
+    }
+  }
+  /** Toggle microphone mute */
+  toggleMute() {
+    if (!this.voiceManager?.isActive) {
+      throw new exports.EstuaryError("VOICE_NOT_ACTIVE" /* VOICE_NOT_ACTIVE */, "Voice is not active");
+    }
+    this.voiceManager.toggleMute();
+  }
+  /** Whether the microphone is muted */
+  get isMuted() {
+    return this.voiceManager?.isMuted ?? false;
+  }
+  /** Whether voice is currently active */
+  get isVoiceActive() {
+    return this.voiceManager?.isActive ?? false;
+  }
+  // ─── Internal ────────────────────────────────────────────────
+  ensureConnected() {
+    if (!this.socketManager.isConnected) {
+      throw new exports.EstuaryError("NOT_CONNECTED" /* NOT_CONNECTED */, "Not connected to server. Call connect() first.");
+    }
+  }
+  forwardSocketEvents() {
+    this.socketManager.on("connected", (session) => {
+      this._sessionInfo = session;
+      this.emit("connected", session);
+    });
+    this.socketManager.on("disconnected", (reason) => {
+      this._sessionInfo = null;
+      this.emit("disconnected", reason);
+    });
+    this.socketManager.on("reconnecting", (attempt) => this.emit("reconnecting", attempt));
+    this.socketManager.on("connectionStateChanged", (state) => this.emit("connectionStateChanged", state));
+    this.socketManager.on("botResponse", (response) => this.emit("botResponse", response));
+    this.socketManager.on("botVoice", (voice) => this.handleBotVoice(voice));
+    this.socketManager.on("sttResponse", (response) => this.emit("sttResponse", response));
+    this.socketManager.on("interrupt", (data) => {
+      this.audioPlayer?.clear();
+      this.emit("interrupt", data);
+    });
+    this.socketManager.on("error", (error) => this.emit("error", error));
+    this.socketManager.on("authError", (error) => this.emit("authError", error));
+    this.socketManager.on("quotaExceeded", (data) => this.emit("quotaExceeded", data));
+    this.socketManager.on("cameraCaptureRequest", (request) => this.emit("cameraCaptureRequest", request));
+    this.socketManager.on("livekitConnected", (room) => this.emit("livekitConnected", room));
+    this.socketManager.on("livekitDisconnected", () => this.emit("livekitDisconnected"));
+    this.socketManager.on("memoryUpdated", (event) => this.emit("memoryUpdated", event));
+  }
+  handleBotVoice(voice) {
+    this.emit("botVoice", voice);
+    this.audioPlayer?.enqueue(voice);
+  }
+};
+
+// src/index.ts
+init_errors();
+
+exports.ConnectionState = ConnectionState;
+exports.EstuaryClient = EstuaryClient;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map