@primoia/vocall-react 0.1.0

package/dist/index.js

@@ -0,0 +1,2015 @@
+// src/protocol/types.ts
+var FieldType = /* @__PURE__ */ ((FieldType2) => {
+  FieldType2["Text"] = "text";
+  FieldType2["Number"] = "number";
+  FieldType2["Currency"] = "currency";
+  FieldType2["Date"] = "date";
+  FieldType2["Datetime"] = "datetime";
+  FieldType2["Email"] = "email";
+  FieldType2["Phone"] = "phone";
+  FieldType2["Masked"] = "masked";
+  FieldType2["Select"] = "select";
+  FieldType2["Autocomplete"] = "autocomplete";
+  FieldType2["Checkbox"] = "checkbox";
+  FieldType2["Radio"] = "radio";
+  FieldType2["Textarea"] = "textarea";
+  FieldType2["File"] = "file";
+  FieldType2["Hidden"] = "hidden";
+  return FieldType2;
+})(FieldType || {});
+var ChatRole = /* @__PURE__ */ ((ChatRole2) => {
+  ChatRole2["User"] = "user";
+  ChatRole2["Agent"] = "agent";
+  ChatRole2["System"] = "system";
+  return ChatRole2;
+})(ChatRole || {});
+var VocallStatus = /* @__PURE__ */ ((VocallStatus2) => {
+  VocallStatus2["Disconnected"] = "disconnected";
+  VocallStatus2["Idle"] = "idle";
+  VocallStatus2["Listening"] = "listening";
+  VocallStatus2["Recording"] = "recording";
+  VocallStatus2["Thinking"] = "thinking";
+  VocallStatus2["Speaking"] = "speaking";
+  VocallStatus2["Executing"] = "executing";
+  return VocallStatus2;
+})(VocallStatus || {});
+
+// src/voice/frame-splitter.ts
+var FrameSplitter = class {
+  constructor(frameSizeBytes = 640) {
+    this.offset = 0;
+    this.frameSizeBytes = frameSizeBytes;
+    this.buffer = new Uint8Array(frameSizeBytes);
+  }
+  /**
+   * Feed arbitrary-length PCM bytes into the splitter.
+   * Whenever a full frame is assembled, `emit` is called with a copy.
+   */
+  feed(pcmBytes, emit) {
+    let srcPos = 0;
+    const srcLen = pcmBytes.length;
+    while (srcPos < srcLen) {
+      const remaining = this.frameSizeBytes - this.offset;
+      const available = srcLen - srcPos;
+      const toCopy = Math.min(available, remaining);
+      this.buffer.set(pcmBytes.subarray(srcPos, srcPos + toCopy), this.offset);
+      this.offset += toCopy;
+      srcPos += toCopy;
+      if (this.offset === this.frameSizeBytes) {
+        emit(new Uint8Array(this.buffer));
+        this.offset = 0;
+      }
+    }
+  }
+  /** Reset the internal buffer, discarding any partial frame. */
+  reset() {
+    this.offset = 0;
+  }
+  /** Number of bytes currently buffered (incomplete frame). */
+  get buffered() {
+    return this.offset;
+  }
+};
+
+// src/voice/web-voice-service.ts
+var TARGET_SAMPLE_RATE = 16e3;
+var FRAME_SIZE_BYTES = 640;
+var SCRIPT_BUFFER_SIZE = 4096;
+var FADE_IN_SAMPLES = 128;
+var SILENT_FRAME = new Uint8Array(FRAME_SIZE_BYTES);
+var WebVoiceService = class {
+  constructor() {
+    // -------------------------------------------------------------------------
+    // Public state
+    // -------------------------------------------------------------------------
+    this.onAudioLevel = null;
+    this.onPlaybackComplete = null;
+    this._isCapturing = false;
+    this._isPlaying = false;
+    this._isMonitoring = false;
+    this._isMuted = false;
+    // -------------------------------------------------------------------------
+    // Private capture state
+    // -------------------------------------------------------------------------
+    this._audioCtx = null;
+    this._stream = null;
+    this._sourceNode = null;
+    this._scriptNode = null;
+    this._splitter = new FrameSplitter(FRAME_SIZE_BYTES);
+    this._sendChunk = null;
+    // -------------------------------------------------------------------------
+    // Private playback state
+    // -------------------------------------------------------------------------
+    this._playbackCtx = null;
+    this._playbackQueue = [];
+    this._currentSource = null;
+    this._pendingDecodes = 0;
+  }
+  get isSupported() {
+    return typeof navigator !== "undefined" && typeof navigator.mediaDevices !== "undefined" && typeof navigator.mediaDevices.getUserMedia === "function" && typeof AudioContext !== "undefined";
+  }
+  get isCapturing() {
+    return this._isCapturing;
+  }
+  get isPlaying() {
+    return this._isPlaying;
+  }
+  get isMonitoring() {
+    return this._isMonitoring;
+  }
+  // -------------------------------------------------------------------------
+  // Capture
+  // -------------------------------------------------------------------------
+  async startCapture(sendChunk) {
+    if (this._isCapturing) return;
+    this._sendChunk = sendChunk;
+    await this._initCapturePipeline(false);
+    this._isCapturing = true;
+  }
+  stopCapture() {
+    this._teardownCapturePipeline();
+    this._isCapturing = false;
+    this._sendChunk = null;
+  }
+  // -------------------------------------------------------------------------
+  // Monitor mode (capture pipeline without sending)
+  // -------------------------------------------------------------------------
+  async startMonitor() {
+    if (this._isMonitoring) return;
+    await this._initCapturePipeline(true);
+    this._isMonitoring = true;
+  }
+  stopMonitor() {
+    this._teardownCapturePipeline();
+    this._isMonitoring = false;
+  }
+  // -------------------------------------------------------------------------
+  // Mute
+  // -------------------------------------------------------------------------
+  muteMic(muted) {
+    this._isMuted = muted;
+    if (this._stream) {
+      const tracks = this._stream.getAudioTracks();
+      for (const track of tracks) {
+        track.enabled = !muted;
+      }
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Playback
+  // -------------------------------------------------------------------------
+  playAudio(wavData) {
+    this._playbackQueue.push(wavData);
+    this._pendingDecodes++;
+    this._isPlaying = true;
+    this._decodeAndEnqueue(wavData);
+  }
+  stopPlayback() {
+    if (this._currentSource) {
+      try {
+        this._currentSource.onended = null;
+        this._currentSource.stop();
+      } catch {
+      }
+      this._currentSource = null;
+    }
+    this._playbackQueue = [];
+    this._pendingDecodes = 0;
+    this._isPlaying = false;
+  }
+  // -------------------------------------------------------------------------
+  // Dispose
+  // -------------------------------------------------------------------------
+  dispose() {
+    this.stopCapture();
+    this.stopMonitor();
+    this.stopPlayback();
+    if (this._audioCtx) {
+      this._audioCtx.close().catch(() => {
+      });
+      this._audioCtx = null;
+    }
+    if (this._playbackCtx) {
+      this._playbackCtx.close().catch(() => {
+      });
+      this._playbackCtx = null;
+    }
+    this.onAudioLevel = null;
+    this.onPlaybackComplete = null;
+  }
+  // -------------------------------------------------------------------------
+  // Private: capture pipeline
+  // -------------------------------------------------------------------------
+  async _initCapturePipeline(monitorOnly) {
+    this._stream = await navigator.mediaDevices.getUserMedia({
+      audio: {
+        channelCount: 1,
+        echoCancellation: true,
+        noiseSuppression: false,
+        autoGainControl: true
+      }
+    });
+    if (!this._audioCtx) {
+      this._audioCtx = new AudioContext();
+    }
+    if (this._audioCtx.state === "suspended") {
+      await this._audioCtx.resume();
+    }
+    const nativeRate = this._audioCtx.sampleRate;
+    this._sourceNode = this._audioCtx.createMediaStreamSource(this._stream);
+    this._scriptNode = this._audioCtx.createScriptProcessor(SCRIPT_BUFFER_SIZE, 1, 1);
+    this._splitter.reset();
+    this._scriptNode.onaudioprocess = (event) => {
+      const inputData = event.inputBuffer.getChannelData(0);
+      this._computeAndEmitLevel(inputData);
+      if (this._isMuted) {
+        if (!monitorOnly && this._sendChunk) {
+          const silentPcm = this._downsampleToS16LE(new Float32Array(inputData.length), nativeRate);
+          this._splitter.feed(silentPcm, (frame) => {
+            this._sendChunk(new Uint8Array(SILENT_FRAME));
+          });
+        }
+        return;
+      }
+      const pcmBytes = this._downsampleToS16LE(inputData, nativeRate);
+      this._splitter.feed(pcmBytes, (frame) => {
+        if (!monitorOnly && this._sendChunk) {
+          this._sendChunk(frame);
+        }
+      });
+    };
+    this._sourceNode.connect(this._scriptNode);
+    this._scriptNode.connect(this._audioCtx.destination);
+  }
+  _teardownCapturePipeline() {
+    if (this._scriptNode) {
+      this._scriptNode.onaudioprocess = null;
+      this._scriptNode.disconnect();
+      this._scriptNode = null;
+    }
+    if (this._sourceNode) {
+      this._sourceNode.disconnect();
+      this._sourceNode = null;
+    }
+    if (this._stream) {
+      for (const track of this._stream.getTracks()) {
+        track.stop();
+      }
+      this._stream = null;
+    }
+    this._splitter.reset();
+    this._isMuted = false;
+  }
+  // -------------------------------------------------------------------------
+  // Private: audio processing
+  // -------------------------------------------------------------------------
+  /**
+   * Downsample Float32 audio at native sample rate to S16LE at TARGET_SAMPLE_RATE
+   * using linear interpolation.
+   */
+  _downsampleToS16LE(input, fromRate) {
+    const ratio = fromRate / TARGET_SAMPLE_RATE;
+    const outputLen = Math.floor(input.length / ratio);
+    const output = new Uint8Array(outputLen * 2);
+    const view = new DataView(output.buffer);
+    for (let i = 0; i < outputLen; i++) {
+      const srcIdx = i * ratio;
+      const srcFloor = Math.floor(srcIdx);
+      const srcCeil = Math.min(srcFloor + 1, input.length - 1);
+      const frac = srcIdx - srcFloor;
+      let sample = input[srcFloor] + (input[srcCeil] - input[srcFloor]) * frac;
+      if (sample > 1) sample = 1;
+      else if (sample < -1) sample = -1;
+      const s16 = Math.round(sample * 32767);
+      view.setInt16(i * 2, s16, true);
+    }
+    return output;
+  }
+  /**
+   * Compute RMS level from Float32 audio samples.
+   * Result is scaled by 4 and clamped to [0, 1].
+   */
+  _computeAndEmitLevel(samples) {
+    if (!this.onAudioLevel) return;
+    let sum = 0;
+    for (let i = 0; i < samples.length; i++) {
+      sum += samples[i] * samples[i];
+    }
+    const rms = Math.sqrt(sum / samples.length);
+    const level = Math.min(rms * 4, 1);
+    this.onAudioLevel(level);
+  }
+  // -------------------------------------------------------------------------
+  // Private: playback pipeline
+  // -------------------------------------------------------------------------
+  async _decodeAndEnqueue(wavData) {
+    if (!this._playbackCtx) {
+      this._playbackCtx = new AudioContext();
+    }
+    if (this._playbackCtx.state === "suspended") {
+      await this._playbackCtx.resume();
+    }
+    try {
+      const arrayBuffer = wavData.buffer.slice(
+        wavData.byteOffset,
+        wavData.byteOffset + wavData.byteLength
+      );
+      const audioBuffer = await this._playbackCtx.decodeAudioData(arrayBuffer);
+      this._applyFadeIn(audioBuffer);
+      this._pendingDecodes--;
+      if (!this._isPlaying) return;
+      if (!this._currentSource) {
+        this._playBuffer(audioBuffer);
+      }
+    } catch {
+      this._pendingDecodes--;
+      this._checkPlaybackComplete();
+    }
+  }
+  _applyFadeIn(audioBuffer) {
+    const fadeLen = Math.min(FADE_IN_SAMPLES, audioBuffer.length);
+    for (let ch = 0; ch < audioBuffer.numberOfChannels; ch++) {
+      const data = audioBuffer.getChannelData(ch);
+      for (let i = 0; i < fadeLen; i++) {
+        data[i] *= i / fadeLen;
+      }
+    }
+  }
+  _playBuffer(audioBuffer) {
+    if (!this._playbackCtx) return;
+    const source = this._playbackCtx.createBufferSource();
+    source.buffer = audioBuffer;
+    source.connect(this._playbackCtx.destination);
+    source.onended = () => {
+      this._currentSource = null;
+      this._playNextChunk();
+    };
+    this._currentSource = source;
+    source.start();
+  }
+  _playNextChunk() {
+    if (this._playbackQueue.length > 0) {
+      this._playbackQueue.shift();
+    }
+    if (this._playbackQueue.length > 0) {
+      const nextData = this._playbackQueue[0];
+      this._pendingDecodes++;
+      this._decodeAndEnqueue(nextData);
+    } else {
+      this._checkPlaybackComplete();
+    }
+  }
+  _checkPlaybackComplete() {
+    if (this._playbackQueue.length === 0 && this._pendingDecodes <= 0) {
+      this._isPlaying = false;
+      this.onPlaybackComplete?.();
+    }
+  }
+};
+
+// src/client/vocall-client.ts
+var TARGET_SAMPLE_RATE2 = 16e3;
+var _VocallClient = class _VocallClient {
+  // -----------------------------------------------------------------------
+  // Constructor
+  // -----------------------------------------------------------------------
+  constructor(serverUrl, options) {
+    // -----------------------------------------------------------------------
+    // Observable state (getters + onChange)
+    // -----------------------------------------------------------------------
+    this._status = "disconnected" /* Disconnected */;
+    this._connected = false;
+    this._messages = [];
+    this._sessionId = null;
+    // -----------------------------------------------------------------------
+    // Voice state (public getters)
+    // -----------------------------------------------------------------------
+    this._voiceEnabled = false;
+    this._voiceState = "idle";
+    this._recording = false;
+    this._partialTranscription = null;
+    this._audioLevel = 0;
+    // -----------------------------------------------------------------------
+    // Voice internals
+    // -----------------------------------------------------------------------
+    this._voiceWs = null;
+    this._alwaysListening = false;
+    this._ttsActive = false;
+    this._ttsEndReceived = false;
+    this._llmDone = false;
+    this._pendingTtsChunks = 0;
+    this._voice = null;
+    // -----------------------------------------------------------------------
+    // Change notification (React hooks subscribe here)
+    // -----------------------------------------------------------------------
+    this._listeners = /* @__PURE__ */ new Set();
+    // -----------------------------------------------------------------------
+    // Callbacks (set by the host app)
+    // -----------------------------------------------------------------------
+    this.onNavigate = null;
+    this.onToast = null;
+    this.onConfirm = null;
+    this.onOpenModal = null;
+    this.onCloseModal = null;
+    // -----------------------------------------------------------------------
+    // Field & action registries
+    // -----------------------------------------------------------------------
+    this._fields = /* @__PURE__ */ new Map();
+    this._actions = /* @__PURE__ */ new Map();
+    // -----------------------------------------------------------------------
+    // Internal state
+    // -----------------------------------------------------------------------
+    this._ws = null;
+    this._manifest = null;
+    this._tokenBuffer = "";
+    this._streamingMessage = null;
+    this._reconnectTimer = null;
+    this._reconnectAttempts = 0;
+    this._intentionalDisconnect = false;
+    this._pendingConfirmSeq = -1;
+    this.serverUrl = serverUrl;
+    this.token = options?.token;
+    this._visitorId = options?.visitorId ?? _VocallClient._loadOrCreateVisitorId();
+  }
+  get visitorId() {
+    return this._visitorId;
+  }
+  set visitorId(id) {
+    this._visitorId = id;
+  }
+  get status() {
+    return this._status;
+  }
+  get connected() {
+    return this._connected;
+  }
+  get messages() {
+    return this._messages;
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  get voiceEnabled() {
+    return this._voiceEnabled;
+  }
+  /** Whether the platform supports voice capture (Web Audio API). */
+  get voiceSupported() {
+    return this._getVoice().isSupported;
+  }
+  get voiceState() {
+    return this._voiceState;
+  }
+  get recording() {
+    return this._recording;
+  }
+  get partialTranscription() {
+    return this._partialTranscription;
+  }
+  get audioLevel() {
+    return this._audioLevel;
+  }
+  _getVoice() {
+    if (!this._voice) {
+      this._voice = new WebVoiceService();
+      this._voice.onAudioLevel = (level) => {
+        this._audioLevel = level;
+        this._notify();
+      };
+      this._voice.onPlaybackComplete = () => {
+        this._onPlaybackComplete();
+      };
+    }
+    return this._voice;
+  }
+  subscribe(listener) {
+    this._listeners.add(listener);
+    return () => {
+      this._listeners.delete(listener);
+    };
+  }
+  _notify() {
+    for (const listener of this._listeners) {
+      listener();
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Visitor ID persistence
+  // -----------------------------------------------------------------------
+  static _generateUuid() {
+    if (typeof crypto !== "undefined" && crypto.randomUUID) {
+      return crypto.randomUUID();
+    }
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+  static _loadOrCreateVisitorId() {
+    const STORAGE_KEY = "vocall_visitor_id";
+    try {
+      const existing = localStorage.getItem(STORAGE_KEY);
+      if (existing) return existing;
+      const id = _VocallClient._generateUuid();
+      localStorage.setItem(STORAGE_KEY, id);
+      return id;
+    } catch {
+      return _VocallClient._generateUuid();
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Field & action registration
+  // -----------------------------------------------------------------------
+  registerField(screenId, fieldId, entry) {
+    if (!this._fields.has(screenId)) {
+      this._fields.set(screenId, /* @__PURE__ */ new Map());
+    }
+    this._fields.get(screenId).set(fieldId, entry);
+  }
+  unregisterField(screenId, fieldId) {
+    this._fields.get(screenId)?.delete(fieldId);
+    if (this._fields.get(screenId)?.size === 0) {
+      this._fields.delete(screenId);
+    }
+  }
+  unregisterScreen(screenId) {
+    this._fields.delete(screenId);
+    this._actions.delete(screenId);
+  }
+  registerAction(screenId, actionId, callback) {
+    if (!this._actions.has(screenId)) {
+      this._actions.set(screenId, /* @__PURE__ */ new Map());
+    }
+    this._actions.get(screenId).set(actionId, callback);
+  }
+  unregisterAction(screenId, actionId) {
+    this._actions.get(screenId)?.delete(actionId);
+  }
+  findField(fieldId) {
+    for (const screen of this._fields.values()) {
+      if (screen.has(fieldId)) return screen.get(fieldId);
+    }
+    return void 0;
+  }
+  findAction(actionId) {
+    for (const screen of this._actions.values()) {
+      if (screen.has(actionId)) return screen.get(actionId);
+    }
+    return void 0;
+  }
+  // -----------------------------------------------------------------------
+  // Connection
+  // -----------------------------------------------------------------------
+  connect(manifest) {
+    this._manifest = manifest;
+    this._intentionalDisconnect = false;
+    this._doConnect();
+  }
+  _doConnect() {
+    this.disconnect(false);
+    const url = new URL(this.serverUrl);
+    url.searchParams.set("visitor_id", this._visitorId);
+    if (this.token) {
+      url.searchParams.set("token", this.token);
+    }
+    try {
+      this._ws = new WebSocket(url.toString());
+      this._ws.onmessage = (event) => {
+        this._onMessage(event.data);
+      };
+      this._ws.onclose = () => {
+        this._onDone();
+      };
+      this._ws.onerror = () => {
+        this._onError();
+      };
+    } catch {
+      this._scheduleReconnect();
+    }
+  }
+  disconnect(intentional = true) {
+    if (intentional) this._intentionalDisconnect = true;
+    if (this._reconnectTimer) {
+      clearTimeout(this._reconnectTimer);
+      this._reconnectTimer = null;
+    }
+    this._closeVoiceWs();
+    if (this._voice) {
+      this._voice.stopCapture();
+      this._voice.stopPlayback();
+    }
+    this._voiceState = "idle";
+    this._recording = false;
+    this._partialTranscription = null;
+    this._audioLevel = 0;
+    this._alwaysListening = false;
+    this._resetTtsState();
+    if (this._ws) {
+      this._ws.onclose = null;
+      this._ws.onerror = null;
+      this._ws.onmessage = null;
+      this._ws.close();
+      this._ws = null;
+    }
+    this._sessionId = null;
+    this._tokenBuffer = "";
+    this._streamingMessage = null;
+    this._pendingConfirmSeq = -1;
+    this._status = "disconnected" /* Disconnected */;
+    this._connected = false;
+    this._notify();
+  }
+  // -----------------------------------------------------------------------
+  // Sending messages
+  // -----------------------------------------------------------------------
+  sendText(text) {
+    if (!text.trim() || !this._ws) return;
+    this._addMessage({ role: "user" /* User */, text, timestamp: /* @__PURE__ */ new Date() });
+    this._wsSend({ type: "text", message: text });
+  }
+  sendConfirm(seq, confirmed) {
+    this._wsSend({ type: "confirm", seq, confirmed });
+    this._pendingConfirmSeq = -1;
+  }
+  sendResult(seq, results, state) {
+    const msg = { type: "result", seq, results };
+    if (state) msg.state = state;
+    this._wsSend(msg);
+  }
+  sendState(state) {
+    this._wsSend(state);
+  }
+  _wsSend(obj) {
+    if (this._ws && this._ws.readyState === WebSocket.OPEN) {
+      this._ws.send(JSON.stringify(obj));
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Incoming message handling
+  // -----------------------------------------------------------------------
+  _onMessage(raw) {
+    let json;
+    try {
+      json = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    const type = json["type"];
+    if (!type) return;
+    switch (type) {
+      case "config":
+        this._handleConfig(json);
+        break;
+      case "chat":
+        this._handleChat(json);
+        break;
+      case "chat_token":
+        this._handleChatToken(json);
+        break;
+      case "chat_end":
+        this._flushTokenBuffer();
+        break;
+      case "status":
+        this._handleStatus(json);
+        break;
+      case "command":
+        this._handleCommand(json);
+        break;
+      case "error":
+        this._handleError(json);
+        break;
+      case "history":
+        this._handleHistory(json);
+        break;
+    }
+  }
+  _handleConfig(config) {
+    this._sessionId = config.sessionId;
+    this._status = "idle" /* Idle */;
+    this._connected = true;
+    this._reconnectAttempts = 0;
+    this._voiceEnabled = config.features?.voice === true;
+    this._notify();
+    if (this._manifest) {
+      this._wsSend(this._manifest);
+    }
+  }
+  _handleHistory(json) {
+    const items = json["messages"];
+    if (!items || !items.length) return;
+    this._messages = [];
+    for (const item of items) {
+      const role = item["role"];
+      const content = item["content"];
+      if (!content) continue;
+      const chatRole = role === "user" ? "user" /* User */ : role === "assistant" ? "agent" /* Agent */ : null;
+      if (!chatRole) continue;
+      this._messages.push({ role: chatRole, text: content, timestamp: /* @__PURE__ */ new Date() });
+    }
+    this._notify();
+  }
+  _handleChat(chat) {
+    this._flushTokenBuffer();
+    this._addMessage({
+      role: "agent" /* Agent */,
+      text: chat.message,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+  _handleChatToken(token) {
+    this._tokenBuffer += token.token;
+    if (this._streamingMessage) {
+      this._streamingMessage.text = this._tokenBuffer;
+    } else {
+      this._streamingMessage = {
+        role: "agent" /* Agent */,
+        text: this._tokenBuffer,
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      this._messages.push(this._streamingMessage);
+    }
+    this._notify();
+  }
+  _flushTokenBuffer() {
+    this._tokenBuffer = "";
+    this._streamingMessage = null;
+  }
+  _handleStatus(status) {
+    this._status = this._mapStatus(status.status);
+    this._notify();
+  }
+  _mapStatus(status) {
+    switch (status) {
+      case "idle":
+        return "idle" /* Idle */;
+      case "listening":
+        return "listening" /* Listening */;
+      case "recording":
+        return "recording" /* Recording */;
+      case "thinking":
+        return "thinking" /* Thinking */;
+      case "speaking":
+        return "speaking" /* Speaking */;
+      case "executing":
+        return "executing" /* Executing */;
+      default:
+        return "idle" /* Idle */;
+    }
+  }
+  _handleError(error) {
+    this._addMessage({
+      role: "system" /* System */,
+      text: error.message,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    this._status = "idle" /* Idle */;
+    this._notify();
+  }
+  // -----------------------------------------------------------------------
+  // Command execution
+  // -----------------------------------------------------------------------
+  async _handleCommand(cmd) {
+    const results = new Array(cmd.actions.length);
+    const sequentialIndices = [];
+    const parallelIndices = [];
+    for (let i = 0; i < cmd.actions.length; i++) {
+      if (_VocallClient.SEQUENTIAL_ACTIONS.has(cmd.actions[i].do)) {
+        sequentialIndices.push(i);
+      } else {
+        parallelIndices.push(i);
+      }
+    }
+    for (const i of sequentialIndices) {
+      try {
+        await this._executeAction(cmd.actions[i], cmd.seq);
+        results[i] = { index: i, success: true };
+      } catch (e) {
+        results[i] = { index: i, success: false, error: String(e) };
+      }
+    }
+    if (parallelIndices.length > 0) {
+      await Promise.all(
+        parallelIndices.map(async (i) => {
+          try {
+            await this._executeAction(cmd.actions[i], cmd.seq);
+            results[i] = { index: i, success: true };
+          } catch (e) {
+            results[i] = { index: i, success: false, error: String(e) };
+          }
+        })
+      );
+    }
+    for (let i = 0; i < results.length; i++) {
+      if (!results[i]) {
+        results[i] = { index: i, success: false, error: "not executed" };
+      }
+    }
+    this.sendResult(cmd.seq, results);
+  }
+  async _executeAction(action, seq) {
+    switch (action.do) {
+      case "navigate":
+        await this._execNavigate(action);
+        break;
+      case "fill":
+        await this._execFill(action);
+        break;
+      case "clear":
+        this._execClear(action);
+        break;
+      case "select":
+        this._execSelect(action);
+        break;
+      case "click":
+        await this._execClick(action);
+        break;
+      case "focus":
+        this._execFocus(action);
+        break;
+      case "highlight":
+        this._execHighlight(action);
+        break;
+      case "scroll_to":
+        this._execScrollTo(action);
+        break;
+      case "show_toast":
+        this._execShowToast(action);
+        break;
+      case "ask_confirm":
+        this._execAskConfirm(action, seq);
+        break;
+      case "open_modal":
+        this._execOpenModal(action);
+        break;
+      case "close_modal":
+        this._execCloseModal();
+        break;
+      case "enable":
+        this._execEnable(action);
+        break;
+      case "disable":
+        this._execDisable(action);
+        break;
+    }
+  }
+  async _execNavigate(action) {
+    const screenId = action.screen;
+    if (!screenId) return;
+    this.onNavigate?.(screenId);
+    await this._sleep(_VocallClient.RETRY_DELAY_MS);
+  }
+  async _execFill(action) {
+    const fieldId = action.field;
+    if (!fieldId) return;
+    let entry = this.findField(fieldId);
+    for (let i = 0; i < _VocallClient.MAX_RETRIES && !entry; i++) {
+      await this._sleep(_VocallClient.RETRY_DELAY_MS);
+      entry = this.findField(fieldId);
+    }
+    if (!entry) {
+      throw new Error(`field "${fieldId}" not registered`);
+    }
+    const value = action.value != null ? String(action.value) : "";
+    const animate = action.animate ?? "typewriter";
+    if (animate === "typewriter" && value.length > 1) {
+      await this._typewriterFill(entry, value, action.speed ?? 40);
+    } else {
+      entry.setValue(value);
+    }
+  }
+  async _typewriterFill(entry, value, speedMs) {
+    entry.element.classList.add("filling");
+    entry.element.focus();
+    entry.setValue("");
+    for (let i = 0; i < value.length; i++) {
+      entry.setValue(value.substring(0, i + 1));
+      await this._sleep(speedMs);
+    }
+    entry.element.classList.remove("filling");
+  }
+  _execClear(action) {
+    const fieldId = action.field;
+    if (!fieldId) return;
+    const entry = this.findField(fieldId);
+    if (entry) entry.setValue("");
+  }
+  _execSelect(action) {
+    const fieldId = action.field;
+    if (!fieldId) return;
+    const entry = this.findField(fieldId);
+    if (entry) entry.setValue(String(action.value ?? ""));
+  }
+  async _execClick(action) {
+    const actionId = action.action;
+    if (!actionId) return;
+    let callback = this.findAction(actionId);
+    for (let i = 0; i < _VocallClient.MAX_RETRIES && !callback; i++) {
+      await this._sleep(_VocallClient.RETRY_DELAY_MS);
+      callback = this.findAction(actionId);
+    }
+    if (!callback) {
+      throw new Error(`action "${actionId}" not registered`);
+    }
+    await callback();
+  }
+  _execFocus(action) {
+    const fieldId = action.field;
+    if (!fieldId) return;
+    const entry = this.findField(fieldId);
+    if (entry) entry.element.focus();
+  }
+  _execHighlight(action) {
+    const fieldId = action.field;
+    if (!fieldId) return;
+    const entry = this.findField(fieldId);
+    if (!entry) return;
+    entry.element.scrollIntoView({ behavior: "smooth", block: "center" });
+    entry.element.classList.add("highlighted");
+    const duration = action.duration ?? 2e3;
+    setTimeout(() => entry.element.classList.remove("highlighted"), duration);
+  }
+  _execScrollTo(action) {
+    const fieldId = action.field;
+    if (!fieldId) return;
+    const entry = this.findField(fieldId);
+    if (entry) entry.element.scrollIntoView({ behavior: "smooth", block: "center" });
+  }
+  _execShowToast(action) {
+    const message = action.message ?? "";
+    const level = action.level ?? "info";
+    const duration = action.duration;
+    this.onToast?.(message, level, duration);
+  }
+  _execAskConfirm(action, seq) {
+    this._pendingConfirmSeq = seq;
+    const message = action.message ?? "Confirmar?";
+    this.onConfirm?.(seq, message);
+  }
+  _execOpenModal(action) {
+    const modalId = action.modal;
+    if (!modalId) return;
+    this.onOpenModal?.(modalId, action.query);
+  }
+  _execCloseModal() {
+    this.onCloseModal?.();
+  }
+  _execEnable(action) {
+    const entry = action.field ? this.findField(action.field) : void 0;
+    if (entry && entry.element instanceof HTMLInputElement) {
+      entry.element.disabled = false;
+    }
+  }
+  _execDisable(action) {
+    const entry = action.field ? this.findField(action.field) : void 0;
+    if (entry && entry.element instanceof HTMLInputElement) {
+      entry.element.disabled = true;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Voice: public methods
+  // -----------------------------------------------------------------------
+  async startAlwaysListening() {
+    if (!this._getVoice().isSupported || !this._connected) return;
+    this._alwaysListening = true;
+    await this._openVoiceWs(false);
+    const voice = this._getVoice();
+    await voice.startCapture((chunk) => {
+      if (this._voiceWs && this._voiceWs.readyState === WebSocket.OPEN) {
+        this._voiceWs.send(chunk);
+      }
+    });
+    this._voiceState = "listening";
+    this._recording = false;
+    this._notify();
+  }
+  stopAlwaysListening() {
+    this._alwaysListening = false;
+    const voice = this._getVoice();
+    voice.stopCapture();
+    voice.stopPlayback();
+    this._closeVoiceWs();
+    this._voiceState = "idle";
+    this._recording = false;
+    this._partialTranscription = null;
+    this._audioLevel = 0;
+    this._resetTtsState();
+    this._notify();
+  }
+  async startRecording() {
+    if (!this._getVoice().isSupported || !this._connected) return;
+    this._alwaysListening = false;
+    await this._openVoiceWs(true);
+    const voice = this._getVoice();
+    await voice.startCapture((chunk) => {
+      if (this._voiceWs && this._voiceWs.readyState === WebSocket.OPEN) {
+        this._voiceWs.send(chunk);
+      }
+    });
+    this._voiceState = "recording";
+    this._recording = true;
+    this._notify();
+  }
+  stopRecording() {
+    const voice = this._getVoice();
+    voice.stopCapture();
+    this._recording = false;
+    this._voiceState = "thinking";
+    this._notify();
+    if (this._voiceWs && this._voiceWs.readyState === WebSocket.OPEN) {
+      this._voiceWs.send(JSON.stringify({ type: "eof" }));
+    }
+  }
+  interrupt() {
+    const voice = this._getVoice();
+    voice.stopPlayback();
+    this._ttsActive = false;
+    if (this._voiceWs && this._voiceWs.readyState === WebSocket.OPEN) {
+      this._voiceWs.send(JSON.stringify({ type: "interrupt" }));
+      this._voiceWs.send(JSON.stringify({ type: "tts_state", active: false }));
+    }
+    if (this._alwaysListening) {
+      voice.muteMic(false);
+      this._voiceState = "listening";
+    } else {
+      this._voiceState = "idle";
+    }
+    this._partialTranscription = null;
+    this._resetTtsState();
+    this._notify();
+  }
+  // -----------------------------------------------------------------------
+  // Voice: private WS management
+  // -----------------------------------------------------------------------
+  async _openVoiceWs(directMode) {
+    this._closeVoiceWs();
+    const url = new URL(this.serverUrl);
+    url.pathname = "/ws/stream";
+    url.searchParams.set("visitor_id", this._visitorId);
+    if (this.token) {
+      url.searchParams.set("token", this.token);
+    }
+    return new Promise((resolve, reject) => {
+      try {
+        this._voiceWs = new WebSocket(url.toString());
+        this._voiceWs.binaryType = "arraybuffer";
+        this._voiceWs.onopen = () => {
+          const config = {
+            type: "config",
+            sample_rate: TARGET_SAMPLE_RATE2
+          };
+          if (directMode) {
+            config["mode"] = "direct";
+          }
+          this._voiceWs.send(JSON.stringify(config));
+          resolve();
+        };
+        this._voiceWs.onmessage = (event) => {
+          this._onVoiceStreamMessage(event);
+        };
+        this._voiceWs.onclose = () => {
+          this._voiceWs = null;
+        };
+        this._voiceWs.onerror = () => {
+          this._voiceWs = null;
+          reject(new Error("Voice WebSocket connection failed"));
+        };
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+  _closeVoiceWs() {
+    if (this._voiceWs) {
+      this._voiceWs.onclose = null;
+      this._voiceWs.onerror = null;
+      this._voiceWs.onmessage = null;
+      this._voiceWs.close();
+      this._voiceWs = null;
+    }
+  }
+  _resetTtsState() {
+    this._ttsActive = false;
+    this._ttsEndReceived = false;
+    this._llmDone = false;
+    this._pendingTtsChunks = 0;
+  }
+  // -----------------------------------------------------------------------
+  // Voice: stream message handler
+  // -----------------------------------------------------------------------
+  _onVoiceStreamMessage(event) {
+    const { data } = event;
+    if (data instanceof ArrayBuffer) {
+      const voice = this._getVoice();
+      voice.playAudio(new Uint8Array(data));
+      return;
+    }
+    let json;
+    try {
+      json = JSON.parse(data);
+    } catch {
+      return;
+    }
+    const type = json["type"];
+    if (!type) return;
+    switch (type) {
+      case "wake_word":
+        this._voiceState = "recording";
+        this._recording = true;
+        this._partialTranscription = null;
+        this._notify();
+        break;
+      case "partial":
+        this._partialTranscription = json["text"] ?? null;
+        this._notify();
+        break;
+      case "transcription":
+        this._partialTranscription = null;
+        this._voiceState = "thinking";
+        this._recording = false;
+        this._notify();
+        break;
+      case "llm_start":
+        this._llmDone = false;
+        break;
+      case "llm_token": {
+        const text = json["text"];
+        if (text) {
+          this._tokenBuffer += text;
+          if (this._streamingMessage) {
+            this._streamingMessage.text = this._tokenBuffer;
+          } else {
+            this._streamingMessage = {
+              role: "agent" /* Agent */,
+              text: this._tokenBuffer,
+              timestamp: /* @__PURE__ */ new Date()
+            };
+            this._messages = [...this._messages, this._streamingMessage];
+          }
+          this._notify();
+        }
+        break;
+      }
+      case "llm_end":
+        this._llmDone = true;
+        this._flushTokenBuffer();
+        this._ttsEndReceived = this._pendingTtsChunks <= 0 && this._llmDone;
+        break;
+      case "tts_start":
+        this._pendingTtsChunks++;
+        this._ttsActive = true;
+        this._ttsEndReceived = false;
+        this._voiceState = "speaking";
+        this._getVoice().muteMic(true);
+        this._notify();
+        break;
+      case "tts_end":
+        this._pendingTtsChunks--;
+        if (this._pendingTtsChunks <= 0 && this._llmDone) {
+          this._ttsEndReceived = true;
+        }
+        break;
+      case "interrupted":
+        this._getVoice().stopPlayback();
+        this._ttsActive = false;
+        this._resetTtsState();
+        if (this._alwaysListening) {
+          this._getVoice().muteMic(false);
+          this._voiceState = "listening";
+        } else {
+          this._voiceState = "idle";
+        }
+        this._partialTranscription = null;
+        this._notify();
+        break;
+      case "conversation_end":
+        this._getVoice().stopPlayback();
+        this._ttsActive = false;
+        this._resetTtsState();
+        if (this._alwaysListening) {
+          this._getVoice().muteMic(false);
+          this._voiceState = "listening";
+        } else {
+          this._voiceState = "idle";
+          this._closeVoiceWs();
+          this._getVoice().stopCapture();
+          this._recording = false;
+        }
+        this._partialTranscription = null;
+        this._notify();
+        break;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Voice: playback completion handler
+  // -----------------------------------------------------------------------
+  _onPlaybackComplete() {
+    if (this._alwaysListening) {
+      if (!this._ttsEndReceived) return;
+      this._finalizeTts();
+    } else {
+    }
+  }
+  _finalizeTts() {
+    this._ttsActive = false;
+    if (this._voiceWs && this._voiceWs.readyState === WebSocket.OPEN) {
+      this._voiceWs.send(JSON.stringify({ type: "tts_state", active: false }));
+    }
+    this._getVoice().muteMic(false);
+    this._voiceState = "listening";
+    this._recording = false;
+    this._partialTranscription = null;
+    this._resetTtsState();
+    this._notify();
+  }
+  // -----------------------------------------------------------------------
+  // Message management
+  // -----------------------------------------------------------------------
+  _addMessage(msg) {
+    this._messages = [...this._messages, msg];
+    this._notify();
+  }
+  clearMessages() {
+    this._messages = [];
+    this._tokenBuffer = "";
+    this._streamingMessage = null;
+    this._notify();
+  }
+  // -----------------------------------------------------------------------
+  // Reconnection
+  // -----------------------------------------------------------------------
+  _onDone() {
+    this._connected = false;
+    this._ws = null;
+    if (this._intentionalDisconnect) {
+      this._notify();
+      return;
+    }
+    this._status = "disconnected" /* Disconnected */;
+    this._notify();
+    this._scheduleReconnect();
+  }
+  _onError() {
+    if (this._intentionalDisconnect) return;
+    this._status = "disconnected" /* Disconnected */;
+    this._connected = false;
+    this._notify();
+    this._scheduleReconnect();
+  }
+  _scheduleReconnect() {
+    if (this._intentionalDisconnect) return;
+    if (this._reconnectAttempts >= _VocallClient.MAX_RECONNECT_ATTEMPTS) return;
+    if (this._reconnectTimer) {
+      clearTimeout(this._reconnectTimer);
+    }
+    const delaySec = Math.min(this._reconnectAttempts + 1, 15);
+    this._reconnectAttempts++;
+    this._reconnectTimer = setTimeout(() => this._doConnect(), delaySec * 1e3);
+  }
+  // -----------------------------------------------------------------------
+  // Helpers
+  // -----------------------------------------------------------------------
+  _sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  // -----------------------------------------------------------------------
+  // Dispose
+  // -----------------------------------------------------------------------
+  destroy() {
+    this.disconnect(true);
+    if (this._voice) {
+      this._voice.dispose();
+      this._voice = null;
+    }
+    this._listeners.clear();
+  }
+};
+_VocallClient.MAX_RECONNECT_ATTEMPTS = 10;
+_VocallClient.RETRY_DELAY_MS = 300;
+_VocallClient.MAX_RETRIES = 3;
+// Sequential actions that must not run in parallel
+_VocallClient.SEQUENTIAL_ACTIONS = /* @__PURE__ */ new Set([
+  "navigate",
+  "click",
+  "open_modal",
+  "close_modal",
+  "ask_confirm",
+  "show_toast"
+]);
+var VocallClient = _VocallClient;
+
+// src/context/vocall-provider.tsx
+import { createContext, useContext, useEffect, useMemo, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+var VocallContext = createContext(null);
+function VocallProvider({ serverUrl, token, visitorId, children }) {
+  const clientRef = useRef(null);
+  const client = useMemo(() => {
+    clientRef.current?.destroy();
+    const c = new VocallClient(serverUrl, { token, visitorId });
+    clientRef.current = c;
+    return c;
+  }, [serverUrl]);
+  client.token = token;
+  useEffect(() => {
+    return () => {
+      clientRef.current?.destroy();
+      clientRef.current = null;
+    };
+  }, []);
+  return /* @__PURE__ */ jsx(VocallContext.Provider, { value: client, children });
+}
+function useVocallClient() {
+  const client = useContext(VocallContext);
+  if (!client) {
+    throw new Error("useVocallClient must be used within a <VocallProvider>");
+  }
+  return client;
+}
+
+// src/hooks/use-vocall.ts
+import { useCallback, useSyncExternalStore } from "react";
+function useVocall() {
+  const client = useVocallClient();
+  const subscribe = useCallback(
+    (onStoreChange) => client.subscribe(onStoreChange),
+    [client]
+  );
+  const status = useSyncExternalStore(
+    subscribe,
+    () => client.status,
+    () => "disconnected" /* Disconnected */
+  );
+  const connected = useSyncExternalStore(
+    subscribe,
+    () => client.connected,
+    () => false
+  );
+  const messages = useSyncExternalStore(
+    subscribe,
+    () => client.messages,
+    () => []
+  );
+  const sessionId = useSyncExternalStore(
+    subscribe,
+    () => client.sessionId,
+    () => null
+  );
+  const voiceEnabled = useSyncExternalStore(
+    subscribe,
+    () => client.voiceEnabled,
+    () => false
+  );
+  const voiceSupported = useSyncExternalStore(
+    subscribe,
+    () => client.voiceSupported,
+    () => false
+  );
+  const voiceState = useSyncExternalStore(
+    subscribe,
+    () => client.voiceState,
+    () => "idle"
+  );
+  const recording = useSyncExternalStore(
+    subscribe,
+    () => client.recording,
+    () => false
+  );
+  const partialTranscription = useSyncExternalStore(
+    subscribe,
+    () => client.partialTranscription,
+    () => null
+  );
+  const sendText = useCallback(
+    (text) => client.sendText(text),
+    [client]
+  );
+  const connect = useCallback(
+    (manifest) => client.connect(manifest),
+    [client]
+  );
+  const disconnect = useCallback(
+    () => client.disconnect(),
+    [client]
+  );
+  const clearMessages = useCallback(
+    () => client.clearMessages(),
+    [client]
+  );
+  return {
+    client,
+    status,
+    messages,
+    connected,
+    sessionId,
+    voiceEnabled,
+    voiceSupported,
+    voiceState,
+    recording,
+    partialTranscription,
+    sendText,
+    connect,
+    disconnect,
+    clearMessages
+  };
+}
+
+// src/hooks/use-vocall-field.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useRef as useRef2, useState } from "react";
+function useVocallField(screenId, fieldId, options) {
+  const client = useVocallClient();
+  const [registered, setRegistered] = useState(false);
+  const elementRef = useRef2(null);
+  const ref = useCallback2(
+    (element) => {
+      if (elementRef.current && registered) {
+        client.unregisterField(screenId, fieldId);
+        setRegistered(false);
+      }
+      elementRef.current = element;
+      if (element) {
+        const isInput = element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement;
+        client.registerField(screenId, fieldId, {
+          element,
+          setValue: options?.setValue ?? ((value) => {
+            if (isInput) {
+              element.value = value;
+              element.dispatchEvent(new Event("input", { bubbles: true }));
+              element.dispatchEvent(new Event("change", { bubbles: true }));
+            }
+          }),
+          getValue: options?.getValue ?? (() => {
+            if (isInput) {
+              return element.value;
+            }
+            return "";
+          })
+        });
+        setRegistered(true);
+      }
+    },
+    [client, screenId, fieldId, options?.setValue, options?.getValue, registered]
+  );
+  useEffect2(() => {
+    return () => {
+      client.unregisterField(screenId, fieldId);
+    };
+  }, [client, screenId, fieldId]);
+  return { ref, registered };
+}
+
+// src/hooks/use-vocall-action.ts
+import { useEffect as useEffect3, useRef as useRef3 } from "react";
+function useVocallAction(screenId, actionId, callback) {
+  const client = useVocallClient();
+  const callbackRef = useRef3(callback);
+  callbackRef.current = callback;
+  useEffect3(() => {
+    const handler = () => callbackRef.current();
+    client.registerAction(screenId, actionId, handler);
+    return () => {
+      client.unregisterAction(screenId, actionId);
+    };
+  }, [client, screenId, actionId]);
+}
+
+// src/hooks/use-vocall-voice.ts
+import { useCallback as useCallback3, useSyncExternalStore as useSyncExternalStore2 } from "react";
+function useVocallVoice() {
+  const client = useVocallClient();
+  const subscribe = useCallback3(
+    (onStoreChange) => client.subscribe(onStoreChange),
+    [client]
+  );
+  const voiceEnabled = useSyncExternalStore2(
+    subscribe,
+    () => client.voiceEnabled,
+    () => false
+  );
+  const voiceState = useSyncExternalStore2(
+    subscribe,
+    () => client.voiceState,
+    () => "idle"
+  );
+  const recording = useSyncExternalStore2(
+    subscribe,
+    () => client.recording,
+    () => false
+  );
+  const partialTranscription = useSyncExternalStore2(
+    subscribe,
+    () => client.partialTranscription,
+    () => null
+  );
+  const audioLevel = useSyncExternalStore2(
+    subscribe,
+    () => client.audioLevel,
+    () => 0
+  );
+  const startAlwaysListening = useCallback3(
+    () => client.startAlwaysListening(),
+    [client]
+  );
+  const stopAlwaysListening = useCallback3(
+    () => client.stopAlwaysListening(),
+    [client]
+  );
+  const startRecording = useCallback3(
+    () => client.startRecording(),
+    [client]
+  );
+  const stopRecording = useCallback3(
+    () => client.stopRecording(),
+    [client]
+  );
+  const interrupt = useCallback3(
+    () => client.interrupt(),
+    [client]
+  );
+  return {
+    voiceEnabled,
+    voiceState,
+    recording,
+    partialTranscription,
+    audioLevel,
+    startAlwaysListening,
+    stopAlwaysListening,
+    startRecording,
+    stopRecording,
+    interrupt
+  };
+}
+
+// src/components/VocallChat.tsx
+import { useCallback as useCallback4, useEffect as useEffect4, useRef as useRef4, useState as useState2 } from "react";
+import { Fragment, jsx as jsx2, jsxs } from "react/jsx-runtime";
+var STATUS_LABELS = {
+  thinking: "Pensando...",
+  executing: "Executando...",
+  speaking: "Falando...",
+  listening: "Ouvindo...",
+  recording: "Gravando..."
+};
+function VocallChat({
+  open,
+  onClose,
+  assistantName = "Emma",
+  className,
+  style
+}) {
+  const { status, messages, connected, voiceSupported, recording, sendText, clearMessages, client } = useVocall();
+  const [input, setInput] = useState2("");
+  const [micActive, setMicActive] = useState2(false);
+  const messagesEndRef = useRef4(null);
+  useEffect4(() => {
+    if (micActive && !recording) {
+      setMicActive(false);
+    }
+  }, [micActive, recording]);
+  const toggleMic = useCallback4(() => {
+    if (micActive) {
+      client.stopRecording();
+      setMicActive(false);
+    } else {
+      client.startRecording();
+      setMicActive(true);
+    }
+  }, [micActive, client]);
+  useEffect4(() => {
+    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [messages]);
+  const handleSend = useCallback4(() => {
+    const text = input.trim();
+    if (!text || !connected) return;
+    sendText(text);
+    setInput("");
+  }, [input, connected, sendText]);
+  const handleKeyDown = useCallback4(
+    (e) => {
+      if (e.key === "Enter" && !e.shiftKey) {
+        e.preventDefault();
+        handleSend();
+      }
+    },
+    [handleSend]
+  );
+  if (!open) return null;
+  const statusLabel = STATUS_LABELS[status] || "";
+  const statusClass = status !== "idle" /* Idle */ ? status : "";
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `vocall-chat-panel ${className || ""}`,
+      style: {
+        position: "fixed",
+        bottom: 76,
+        right: 16,
+        width: 360,
+        height: 560,
+        background: "#fff",
+        borderRadius: 16,
+        boxShadow: "0 8px 32px rgba(0,0,0,0.15)",
+        display: "flex",
+        flexDirection: "column",
+        zIndex: 999,
+        overflow: "hidden",
+        ...style
+      },
+      children: [
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: `vocall-chat-header ${statusClass}`,
+            style: {
+              padding: "8px 12px",
+              background: "#1E293B",
+              borderRadius: "16px 16px 0 0",
+              display: "flex",
+              alignItems: "center",
+              gap: 8,
+              borderBottom: `2px solid ${statusClass ? _statusBorderColor(status) : "transparent"}`,
+              transition: "border-color 0.3s"
+            },
+            children: [
+              /* @__PURE__ */ jsx2(
+                "div",
+                {
+                  style: {
+                    width: 8,
+                    height: 8,
+                    borderRadius: "50%",
+                    background: connected ? "#22C55E" : "#EF4444",
+                    boxShadow: connected ? "0 0 6px rgba(34,197,94,0.6)" : "none",
+                    flexShrink: 0
+                  }
+                }
+              ),
+              /* @__PURE__ */ jsx2("span", { style: { fontSize: 13, fontWeight: 600, color: "#fff" }, children: assistantName }),
+              statusLabel && /* @__PURE__ */ jsxs(Fragment, { children: [
+                /* @__PURE__ */ jsx2("span", { style: { fontSize: 13, color: "#CBD5E1" }, children: "\xB7" }),
+                /* @__PURE__ */ jsx2("span", { style: { fontSize: 12, fontWeight: 500, color: _statusColor(status) }, children: statusLabel })
+              ] }),
+              /* @__PURE__ */ jsx2("div", { style: { flex: 1 } }),
+              /* @__PURE__ */ jsx2(
+                "button",
+                {
+                  onClick: clearMessages,
+                  title: "Limpar",
+                  style: {
+                    width: 28,
+                    height: 28,
+                    display: "flex",
+                    alignItems: "center",
+                    justifyContent: "center",
+                    border: "none",
+                    background: "none",
+                    color: "#CBD5E1",
+                    cursor: "pointer",
+                    borderRadius: 6,
+                    fontSize: 14
+                  },
+                  children: "\u{1F5D1}"
+                }
+              ),
+              /* @__PURE__ */ jsx2(
+                "button",
+                {
+                  onClick: onClose,
+                  title: "Fechar",
+                  style: {
+                    width: 28,
+                    height: 28,
+                    display: "flex",
+                    alignItems: "center",
+                    justifyContent: "center",
+                    border: "none",
+                    background: "none",
+                    color: "#CBD5E1",
+                    cursor: "pointer",
+                    borderRadius: 6,
+                    fontSize: 14
+                  },
+                  children: "\u2715"
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            style: {
+              flex: 1,
+              overflowY: "auto",
+              padding: 12,
+              display: "flex",
+              flexDirection: "column",
+              gap: 6
+            },
+            children: [
+              messages.length === 0 ? /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  style: {
+                    flex: 1,
+                    display: "flex",
+                    flexDirection: "column",
+                    alignItems: "center",
+                    justifyContent: "center",
+                    color: "#94A3B8",
+                    gap: 8
+                  },
+                  children: [
+                    /* @__PURE__ */ jsx2("span", { style: { fontSize: 32 }, children: "\u{1F4AC}" }),
+                    /* @__PURE__ */ jsx2("span", { style: { fontSize: 13 }, children: connected ? `Diga algo para a ${assistantName}` : "Conecte-se para conversar" })
+                  ]
+                }
+              ) : messages.map((msg, i) => /* @__PURE__ */ jsx2(
+                "div",
+                {
+                  style: {
+                    display: "flex",
+                    maxWidth: 280,
+                    alignSelf: msg.role === "user" /* User */ ? "flex-end" : msg.role === "system" /* System */ ? "center" : "flex-start"
+                  },
+                  children: /* @__PURE__ */ jsx2(
+                    "div",
+                    {
+                      style: {
+                        padding: "8px 12px",
+                        borderRadius: 12,
+                        fontSize: 13,
+                        lineHeight: 1.5,
+                        wordBreak: "break-word",
+                        ..._bubbleStyle(msg.role)
+                      },
+                      children: msg.text
+                    }
+                  )
+                },
+                i
+              )),
+              /* @__PURE__ */ jsx2("div", { ref: messagesEndRef })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            style: {
+              padding: "6px 8px 10px 12px",
+              display: "flex",
+              alignItems: "center",
+              gap: 6,
+              borderTop: "1px solid #E2E8F0"
+            },
+            children: [
+              /* @__PURE__ */ jsx2(
+                "input",
+                {
+                  type: "text",
+                  value: input,
+                  onChange: (e) => setInput(e.target.value),
+                  onKeyDown: handleKeyDown,
+                  disabled: !connected || micActive,
+                  placeholder: micActive ? "Gravando... clique para parar" : "Digite uma mensagem...",
+                  style: {
+                    flex: 1,
+                    padding: "10px 12px",
+                    fontSize: 13,
+                    fontFamily: "inherit",
+                    border: "1px solid #E2E8F0",
+                    borderRadius: 10,
+                    background: "#F8FAFC",
+                    color: micActive ? "#FF4060" : "#1E293B",
+                    outline: "none",
+                    opacity: connected ? 1 : 0.5
+                  }
+                }
+              ),
+              voiceSupported && /* @__PURE__ */ jsx2(
+                "button",
+                {
+                  onClick: toggleMic,
+                  disabled: !connected,
+                  style: {
+                    width: 36,
+                    height: 36,
+                    display: "flex",
+                    alignItems: "center",
+                    justifyContent: "center",
+                    border: "none",
+                    borderRadius: "50%",
+                    background: micActive ? "#FF4060" : "#3B82F6",
+                    color: "#fff",
+                    cursor: connected ? "pointer" : "not-allowed",
+                    flexShrink: 0
+                  },
+                  children: /* @__PURE__ */ jsx2("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "currentColor", children: micActive ? /* @__PURE__ */ jsx2("rect", { x: "6", y: "6", width: "12", height: "12", rx: "2" }) : /* @__PURE__ */ jsx2("path", { d: "M12 14c1.66 0 3-1.34 3-3V5c0-1.66-1.34-3-3-3S9 3.34 9 5v6c0 1.66 1.34 3 3 3zm-1-9c0-.55.45-1 1-1s1 .45 1 1v6c0 .55-.45 1-1 1s-1-.45-1-1V5zm6 6c0 2.76-2.24 5-5 5s-5-2.24-5-5H5c0 3.53 2.61 6.43 6 6.92V21h2v-3.08c3.39-.49 6-3.39 6-6.92h-2z" }) })
+                }
+              ),
+              /* @__PURE__ */ jsx2(
+                "button",
+                {
+                  onClick: handleSend,
+                  disabled: !connected || !input.trim() || micActive,
+                  style: {
+                    width: 36,
+                    height: 36,
+                    display: "flex",
+                    alignItems: "center",
+                    justifyContent: "center",
+                    border: "none",
+                    borderRadius: "50%",
+                    background: connected && input.trim() && !micActive ? "#3B82F6" : "#CBD5E1",
+                    color: "#fff",
+                    cursor: connected && input.trim() && !micActive ? "pointer" : "not-allowed",
+                    flexShrink: 0,
+                    fontSize: 16
+                  },
+                  children: "\u27A4"
+                }
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+function _bubbleStyle(role) {
+  switch (role) {
+    case "user" /* User */:
+      return { background: "#3B82F6", color: "#fff" };
+    case "agent" /* Agent */:
+      return { background: "#F1F5F9", color: "#1E293B" };
+    case "system" /* System */:
+      return {
+        background: "rgba(245,158,11,0.08)",
+        color: "#F59E0B",
+        fontSize: 11,
+        fontStyle: "italic",
+        textAlign: "center",
+        maxWidth: "100%"
+      };
+  }
+}
+function _statusBorderColor(status) {
+  switch (status) {
+    case "thinking" /* Thinking */:
+      return "#8B5CF6";
+    case "executing" /* Executing */:
+      return "#F59E0B";
+    case "speaking" /* Speaking */:
+      return "#FFB347";
+    case "listening" /* Listening */:
+      return "#00D4FF";
+    case "recording" /* Recording */:
+      return "#FF4060";
+    default:
+      return "transparent";
+  }
+}
+function _statusColor(status) {
+  switch (status) {
+    case "thinking" /* Thinking */:
+      return "#8B5CF6";
+    case "executing" /* Executing */:
+      return "#F59E0B";
+    case "speaking" /* Speaking */:
+      return "#FFB347";
+    case "listening" /* Listening */:
+      return "#00D4FF";
+    case "recording" /* Recording */:
+      return "#FF4060";
+    default:
+      return "#94A3B8";
+  }
+}
+
+// src/components/VocallFab.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+var FAB_COLORS = {
+  disconnected: { bg: "#94A3B8", shadow: "rgba(148,163,184,0.3)" },
+  idle: { bg: "#3B82F6", shadow: "rgba(59,130,246,0.35)" },
+  thinking: { bg: "#8B5CF6", shadow: "rgba(139,92,246,0.4)" },
+  executing: { bg: "#F59E0B", shadow: "rgba(245,158,11,0.4)" },
+  speaking: { bg: "#FFB347", shadow: "rgba(255,179,71,0.4)" },
+  listening: { bg: "#00D4FF", shadow: "rgba(0,212,255,0.4)" },
+  recording: { bg: "#FF4060", shadow: "rgba(255,64,96,0.4)" }
+};
+function VocallFab({ onClick, className, style }) {
+  const { status, connected } = useVocall();
+  const key = !connected ? "disconnected" : status;
+  const colors = FAB_COLORS[key] ?? FAB_COLORS.idle;
+  const isSpinner = status === "thinking" /* Thinking */ || status === "executing" /* Executing */;
+  const isVoiceActive = status === "listening" /* Listening */ || status === "recording" /* Recording */ || status === "speaking" /* Speaking */;
+  return /* @__PURE__ */ jsx3(
+    "button",
+    {
+      className: `vocall-fab ${className || ""}`,
+      onClick,
+      style: {
+        position: "fixed",
+        bottom: 16,
+        right: 16,
+        width: 52,
+        height: 52,
+        borderRadius: "50%",
+        background: colors.bg,
+        color: "#fff",
+        border: "none",
+        cursor: "pointer",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        boxShadow: `0 4px 12px ${colors.shadow}`,
+        transition: "all 0.3s ease-in-out",
+        zIndex: 1e3,
+        fontSize: 24,
+        ...style
+      },
+      children: isSpinner ? /* @__PURE__ */ jsx3(
+        "div",
+        {
+          style: {
+            width: 24,
+            height: 24,
+            border: "2px solid rgba(255,255,255,0.3)",
+            borderTopColor: "#fff",
+            borderRadius: "50%",
+            animation: "vocall-spin 0.8s linear infinite"
+          }
+        }
+      ) : isVoiceActive ? /* @__PURE__ */ jsx3("svg", { width: "24", height: "24", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ jsx3("path", { d: "M12 14c1.66 0 3-1.34 3-3V5c0-1.66-1.34-3-3-3S9 3.34 9 5v6c0 1.66 1.34 3 3 3zm-1-9c0-.55.45-1 1-1s1 .45 1 1v6c0 .55-.45 1-1 1s-1-.45-1-1V5zm6 6c0 2.76-2.24 5-5 5s-5-2.24-5-5H5c0 3.53 2.61 6.43 6 6.92V21h2v-3.08c3.39-.49 6-3.39 6-6.92h-2z" }) }) : /* @__PURE__ */ jsx3("span", { children: "\u{1F916}" })
+    }
+  );
+}
+
+// src/components/VocallStatus.tsx
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+var STATUS_CONFIG = {
+  thinking: { label: "Pensando...", bg: "rgba(139,92,246,0.12)", color: "#8B5CF6" },
+  executing: { label: "Executando...", bg: "rgba(245,158,11,0.12)", color: "#F59E0B" },
+  speaking: { label: "Falando...", bg: "rgba(255,179,71,0.12)", color: "#FFB347" },
+  listening: { label: "Ouvindo...", bg: "rgba(0,212,255,0.12)", color: "#00D4FF" },
+  recording: { label: "Gravando...", bg: "rgba(239,68,68,0.12)", color: "#FF4060" }
+};
+function VocallStatusPill({ className, style }) {
+  const { status, connected } = useVocall();
+  const config = STATUS_CONFIG[status];
+  if (!config || !connected || status === "idle" /* Idle */ || status === "disconnected" /* Disconnected */) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      className: `vocall-status-pill ${className || ""}`,
+      style: {
+        display: "inline-flex",
+        alignItems: "center",
+        gap: 6,
+        padding: "4px 10px",
+        borderRadius: 12,
+        fontSize: 11,
+        fontWeight: 500,
+        background: config.bg,
+        color: config.color,
+        ...style
+      },
+      children: [
+        /* @__PURE__ */ jsx4(
+          "div",
+          {
+            style: {
+              width: 12,
+              height: 12,
+              border: "1.5px solid currentColor",
+              borderTopColor: "transparent",
+              borderRadius: "50%",
+              animation: "vocall-spin 0.8s linear infinite"
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx4("span", { children: config.label })
+      ]
+    }
+  );
+}
+export {
+  ChatRole,
+  FieldType,
+  FrameSplitter,
+  VocallChat,
+  VocallClient,
+  VocallFab,
+  VocallProvider,
+  VocallStatus,
+  VocallStatusPill,
+  WebVoiceService,
+  useVocall,
+  useVocallAction,
+  useVocallClient,
+  useVocallField,
+  useVocallVoice
+};
+//# sourceMappingURL=index.js.map