callix-dialer-widget 2.5.1 → 2.6.0

package/dist-widget/callix-dialer.es.js

@@ -6,7 +6,7 @@ var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read fr
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-import React, { useState, useMemo, useRef, useEffect, useCallback, forwardRef, useLayoutEffect, useId, createContext, useImperativeHandle, StrictMode, useContext } from "react";
+import React, { createContext, useMemo, useSyncExternalStore, useRef, useCallback, useContext, useEffect, useState, forwardRef, useLayoutEffect, useId, useImperativeHandle, StrictMode } from "react";
 import require$$0$2, { createPortal } from "react-dom";
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getAugmentedNamespace(n) {
@@ -43725,6 +43725,790 @@ function requireClientSdkReact() {
   return clientSdkReact;
 }
 var clientSdkReactExports = requireClientSdkReact();
+class EngineSignal {
+  constructor(value) {
+    this.value = value;
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  get() {
+    return this.value;
+  }
+  set(value) {
+    if (JSON.stringify(value) === JSON.stringify(this.value)) return;
+    this.value = value;
+    for (const listener of this.listeners) listener(value);
+  }
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+}
+const INITIAL_TRANSCRIPT = { segments: [], status: null, insight: null, interims: 0 };
+const MAX_SEGMENTS = 300;
+const RECONNECT_MIN_MS = 500;
+const RECONNECT_MAX_MS = 5e3;
+function engineWsUrl(baseUrl) {
+  const url = new URL(baseUrl, typeof window !== "undefined" ? window.location.href : "http://localhost");
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.pathname = `${url.pathname.replace(/\/+$/, "")}/ws`;
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+}
+class EngineClient {
+  constructor(options) {
+    this.options = options;
+    this.userSignal = new EngineSignal(void 0);
+    this.listeners = /* @__PURE__ */ new Set();
+    this.sessionLostListeners = /* @__PURE__ */ new Set();
+    this.viewWaiters = [];
+    this.ws = null;
+    this.reconnectDelay = RECONNECT_MIN_MS;
+    this.reconnectTimer = null;
+    this.closed = false;
+    this.iceServers = [{ urls: "stun:stun.l.google.com:19302" }];
+    this.pc = null;
+    this.connectionId = null;
+    this.remoteSet = false;
+    this.pendingCandidates = [];
+    this.micStream = null;
+    this.audioSeq = 0;
+    this.unlockListener = null;
+    this.agentId = options.agentId;
+    this.session = options.session ?? null;
+    this.log = options.log ?? (() => void 0);
+    this.audio = options.audioElement !== void 0 ? options.audioElement : createAudioElement();
+    this.state = {
+      wsState: "idle",
+      tabId: null,
+      view: null,
+      engaged: false,
+      pcState: "idle",
+      needsUnlock: false,
+      micError: null,
+      lastError: null,
+      inputMuted: false,
+      outputMuted: false,
+      outputVolume: 100,
+      transcript: INITIAL_TRANSCRIPT,
+      sessionLost: null
+    };
+  }
+  // ------------------------------------------------------------------ store
+  getState() {
+    return this.state;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  setState(patch) {
+    this.state = { ...this.state, ...patch };
+    for (const listener of this.listeners) listener();
+  }
+  get currentCall() {
+    var _a2, _b;
+    return ((_b = (_a2 = this.state.view) == null ? void 0 : _a2.snapshot) == null ? void 0 : _b.leg.call) ?? null;
+  }
+  // ------------------------------------------------------------------ conexão
+  connect() {
+    if (this.closed) this.closed = false;
+    if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) return;
+    const Impl = this.options.WebSocketImpl ?? WebSocket;
+    this.setState({ wsState: "connecting" });
+    const ws = new Impl(engineWsUrl(this.options.url));
+    this.ws = ws;
+    ws.onopen = () => {
+      if (this.ws !== ws) return;
+      this.reconnectDelay = RECONNECT_MIN_MS;
+      this.setState({ wsState: "open" });
+      const hello = { type: "hello", role: "tab", agentId: this.agentId, token: this.options.token, label: this.options.label ?? "Discador", ...this.session ? { session: this.session } : {} };
+      this.send(hello);
+      this.log("conectado ao host do motor");
+    };
+    ws.onmessage = (event) => {
+      if (this.ws !== ws) return;
+      let message;
+      try {
+        message = JSON.parse(String(event.data));
+      } catch {
+        return;
+      }
+      this.handle(message);
+    };
+    ws.onclose = () => {
+      if (this.ws !== ws) return;
+      this.ws = null;
+      const wasEngaged = this.state.engaged;
+      this.setState({ wsState: "closed", tabId: null, engaged: false });
+      if (wasEngaged) this.stopAudio();
+      if (this.closed) return;
+      this.log(`conexão com o motor caiu; nova tentativa em ${this.reconnectDelay} ms`);
+      this.reconnectTimer = setTimeout(() => {
+        this.reconnectTimer = null;
+        this.connect();
+      }, this.reconnectDelay);
+      this.reconnectDelay = Math.min(this.reconnectDelay * 2, RECONNECT_MAX_MS);
+    };
+    ws.onerror = () => void 0;
+  }
+  /** fecha de vez (sem reconectar) e solta o áudio */
+  close() {
+    this.closed = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.stopAudio();
+    const ws = this.ws;
+    this.ws = null;
+    if (ws) {
+      ws.onclose = null;
+      ws.close();
+    }
+    for (const waiter of this.viewWaiters.splice(0)) clearTimeout(waiter.timer);
+    this.setState({ wsState: "closed", tabId: null, engaged: false });
+  }
+  /** a view atual, ou a próxima que o host mandar (welcome/view) */
+  waitForView(timeoutMs = 15e3) {
+    if (this.state.view && this.state.tabId) return Promise.resolve(this.state.view);
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const index = this.viewWaiters.findIndex((w) => w.timer === timer);
+        if (index >= 0) this.viewWaiters.splice(index, 1);
+        reject(new Error("o motor não respondeu"));
+      }, timeoutMs);
+      this.viewWaiters.push({ resolve, timer });
+    });
+  }
+  send(message) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) this.ws.send(JSON.stringify(message));
+  }
+  handle(message) {
+    switch (message.type) {
+      case "welcome": {
+        if (Array.isArray(message.iceServers) && message.iceServers.length > 0) this.iceServers = message.iceServers;
+        this.setState({ tabId: message.tabId });
+        this.applyView(message.view);
+        this.log(`sou a aba ${message.tabId}`);
+        if (this.options.autoEngage !== false && message.view.engagedTabId !== message.tabId) this.engage();
+        break;
+      }
+      case "view":
+        this.applyView(message.view);
+        break;
+      case "engage":
+        this.setState({ engaged: message.engaged });
+        if (message.engaged) void this.startAudio();
+        else this.stopAudio();
+        break;
+      case "signal":
+        void this.onSignal(message.payload);
+        break;
+      case "error":
+        this.setState({ lastError: message.message });
+        this.log(`erro do host: ${message.message}`);
+        break;
+      case "transcript":
+        this.pushSegment(message.segment);
+        break;
+      case "transcript-sync":
+        this.setState({ transcript: { segments: message.segments ?? [], status: message.status ?? null, insight: message.insight ?? null, interims: 0 } });
+        break;
+      case "insight": {
+        const current = this.state.transcript.insight;
+        if (!current || message.insight.revision >= current.revision || message.insight.callId !== current.callId) {
+          this.setState({ transcript: { ...this.state.transcript, insight: message.insight } });
+        }
+        break;
+      }
+      case "transcript-status":
+        this.onTranscriptStatus(message.status);
+        break;
+    }
+  }
+  applyView(view) {
+    var _a2, _b;
+    const previous = this.state.view;
+    const lost = view.sessionLost ?? null;
+    const newlyLost = Boolean(lost) && !(previous == null ? void 0 : previous.sessionLost);
+    if (newlyLost) {
+      this.session = null;
+      this.log(`o Callix derrubou a sessão: ${(lost == null ? void 0 : lost.message) ?? ""}`);
+    }
+    const user = (_a2 = view.snapshot) == null ? void 0 : _a2.leg.user;
+    this.userSignal.set(user ? { ...user, sessionId: 0 } : void 0);
+    const call = (_b = view.snapshot) == null ? void 0 : _b.leg.call;
+    const patch = { view, sessionLost: lost ? { originator: lost.originator, message: lost.message } : null };
+    if (call && typeof call.muted === "boolean" && call.muted !== this.state.inputMuted && call.state !== "ended") patch.inputMuted = call.muted;
+    this.setState(patch);
+    for (const waiter of this.viewWaiters.splice(0)) {
+      clearTimeout(waiter.timer);
+      waiter.resolve(view);
+    }
+    if (newlyLost && lost) for (const listener of this.sessionLostListeners) listener(lost);
+  }
+  onSessionLost(listener) {
+    this.sessionLostListeners.add(listener);
+    return () => {
+      this.sessionLostListeners.delete(listener);
+    };
+  }
+  // ------------------------------------------------------------------ sessão e comandos
+  /** modo sdk: o widget fez login no back-end e entrega a sessão ao host */
+  setSession(session) {
+    this.session = session;
+    this.send({ type: "session", session });
+  }
+  engage() {
+    this.send({ type: "engage" });
+  }
+  release() {
+    this.send({ type: "release" });
+  }
+  command(command) {
+    this.send({ type: "command", command });
+    this.log(`comando: ${command.name}${command.phone ? ` ${command.phone}` : ""}`);
+  }
+  // ------------------------------------------------------------------ áudio
+  setInputMuted(muted) {
+    if (this.micStream) for (const track of this.micStream.getAudioTracks()) track.enabled = !muted;
+    this.setState({ inputMuted: muted });
+    if (this.currentCall) this.command({ name: muted ? "mute" : "unmute" });
+  }
+  setOutputMuted(muted) {
+    if (this.audio) this.audio.muted = muted;
+    this.setState({ outputMuted: muted });
+  }
+  setOutputVolume(volume) {
+    const clamped = Math.max(0, Math.min(100, Math.round(volume)));
+    if (this.audio) this.audio.volume = clamped / 100;
+    this.setState({ outputVolume: clamped });
+  }
+  async setOutputDevice(deviceId) {
+    const audio = this.audio;
+    if (!(audio == null ? void 0 : audio.setSinkId)) throw new Error("este navegador não permite escolher a saída de som");
+    await audio.setSinkId(deviceId);
+  }
+  /** depois de um toque do agente: tenta tocar o som do motor que o navegador segurou */
+  async unlockAudio() {
+    if (!this.audio || !this.audio.srcObject) return;
+    try {
+      await this.audio.play();
+      this.setState({ needsUnlock: false });
+    } catch {
+      this.setState({ needsUnlock: true });
+    }
+  }
+  async startAudio() {
+    const seq = ++this.audioSeq;
+    this.stopAudio();
+    const mediaDevices = this.options.mediaDevices === void 0 ? typeof navigator !== "undefined" ? navigator.mediaDevices : null : this.options.mediaDevices;
+    if (!(mediaDevices == null ? void 0 : mediaDevices.getUserMedia)) {
+      this.setState({ micError: "Este navegador não permite usar o microfone pela página." });
+      return;
+    }
+    let stream;
+    try {
+      stream = await mediaDevices.getUserMedia({ audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: true } });
+    } catch (error2) {
+      const message = `Microfone indisponível: ${error2.message}`;
+      this.setState({ micError: message });
+      this.log(message);
+      return;
+    }
+    if (seq !== this.audioSeq || !this.state.engaged) {
+      for (const track of stream.getTracks()) track.stop();
+      return;
+    }
+    this.micStream = stream;
+    for (const track of stream.getAudioTracks()) track.enabled = !this.state.inputMuted;
+    this.setState({ micError: null });
+    const Impl = this.options.PeerConnectionImpl ?? RTCPeerConnection;
+    const connection = new Impl({ iceServers: this.iceServers });
+    this.pc = connection;
+    const connectionId = Math.random().toString(36).slice(2, 10);
+    this.connectionId = connectionId;
+    this.remoteSet = false;
+    this.pendingCandidates = [];
+    for (const track of stream.getAudioTracks()) connection.addTrack(track, stream);
+    connection.onicecandidate = (event) => {
+      this.send({ type: "signal", payload: { connectionId, candidate: event.candidate ? event.candidate.toJSON() : null } });
+    };
+    connection.ontrack = (event) => {
+      const remote = event.streams[0] ?? new MediaStream([event.track]);
+      if (this.audio) {
+        this.audio.srcObject = remote;
+        this.audio.muted = this.state.outputMuted;
+        this.audio.volume = this.state.outputVolume / 100;
+        this.audio.play().then(() => this.setState({ needsUnlock: false })).catch(() => {
+          this.setState({ needsUnlock: true });
+          this.armUnlock();
+        });
+      }
+      this.log("áudio do motor chegou");
+    };
+    connection.onconnectionstatechange = () => {
+      if (this.pc !== connection) return;
+      this.setState({ pcState: connection.connectionState });
+      this.log(`WebRTC: ${connection.connectionState}`);
+      if (connection.connectionState === "failed" && this.state.engaged) {
+        this.log("conexão de áudio com o motor falhou; renegociando");
+        void this.startAudio();
+      }
+    };
+    const offer = await connection.createOffer();
+    if (this.pc !== connection) return;
+    await connection.setLocalDescription(offer);
+    this.send({ type: "signal", payload: { connectionId, description: { type: offer.type, sdp: offer.sdp } } });
+    this.setState({ pcState: connection.connectionState });
+  }
+  stopAudio() {
+    if (this.pc) {
+      this.pc.onconnectionstatechange = null;
+      this.pc.onicecandidate = null;
+      this.pc.ontrack = null;
+      this.pc.close();
+      this.pc = null;
+    }
+    this.connectionId = null;
+    if (this.micStream) {
+      for (const track of this.micStream.getTracks()) track.stop();
+      this.micStream = null;
+    }
+    if (this.audio) this.audio.srcObject = null;
+    if (this.state.pcState !== "idle") this.setState({ pcState: "idle" });
+  }
+  async onSignal(payload) {
+    const connection = this.pc;
+    if (!connection) return;
+    if (payload.connectionId && payload.connectionId !== this.connectionId) return;
+    try {
+      if (payload.description) {
+        await connection.setRemoteDescription(payload.description);
+        this.remoteSet = true;
+        for (const candidate of this.pendingCandidates.splice(0)) await connection.addIceCandidate(candidate).catch(() => void 0);
+      }
+      if (payload.candidate !== void 0) {
+        const candidate = payload.candidate ?? void 0;
+        if (!this.remoteSet && candidate) this.pendingCandidates.push(candidate);
+        else await connection.addIceCandidate(candidate).catch(() => void 0);
+      }
+    } catch (error2) {
+      this.log(`sinalização: ${error2.message}`);
+    }
+  }
+  /** o próximo toque/tecla na página libera o som (política de autoplay) */
+  armUnlock() {
+    if (this.unlockListener || typeof document === "undefined") return;
+    const listener = () => {
+      document.removeEventListener("pointerdown", listener, true);
+      document.removeEventListener("keydown", listener, true);
+      this.unlockListener = null;
+      void this.unlockAudio();
+    };
+    this.unlockListener = listener;
+    document.addEventListener("pointerdown", listener, true);
+    document.addEventListener("keydown", listener, true);
+  }
+  // ------------------------------------------------------------------ transcrição
+  pushSegment(segment) {
+    const current = this.state.transcript;
+    let segments = current.segments;
+    let insight = current.insight;
+    let interims = current.interims;
+    if (segments.length && segments[0].callId !== segment.callId) {
+      segments = [];
+      insight = null;
+      interims = 0;
+    }
+    const index = segments.findIndex((s) => s.id === segment.id);
+    const next = index >= 0 ? segments.map((s, i2) => i2 === index ? segment : s) : [...segments, segment];
+    if (next.length > MAX_SEGMENTS) next.shift();
+    if (segment.interim) interims += 1;
+    this.setState({ transcript: { ...current, segments: next, insight, interims } });
+  }
+  onTranscriptStatus(status) {
+    const current = this.state.transcript;
+    if (!current.status || current.status.recordingId === status.recordingId || status.live === "running") {
+      const fresh = current.status && current.status.recordingId !== status.recordingId;
+      this.setState({ transcript: { ...current, status, ...fresh ? { segments: [], insight: null, interims: 0 } : {} } });
+    }
+  }
+}
+function createAudioElement() {
+  if (typeof document === "undefined") return null;
+  const audio = document.createElement("audio");
+  audio.autoplay = true;
+  audio.setAttribute("playsinline", "true");
+  audio.style.display = "none";
+  audio.dataset.callixEngineAudio = "true";
+  document.body.appendChild(audio);
+  return audio;
+}
+const EngineClientContext = createContext(null);
+function EngineClientProvider({ client: client2, children: children2 }) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(EngineClientContext.Provider, { value: client2, children: children2 });
+}
+function useEngineClient() {
+  return useContext(EngineClientContext);
+}
+function useEngineState(client2) {
+  return useSyncExternalStore(client2.subscribe.bind(client2), client2.getState.bind(client2), client2.getState.bind(client2));
+}
+const ENGINE_BREAKS = [{ id: 0, name: "Pausa" }];
+function toCallQualification(q) {
+  return { id: q.id, name: q.name, isSystemQualification: false, systemQualificationType: 0 };
+}
+function qualificationsFromView(view, kind) {
+  var _a2;
+  return (((_a2 = view == null ? void 0 : view.snapshot) == null ? void 0 : _a2.leg.qualifications) ?? []).filter((q) => q.kind === kind).map(toCallQualification);
+}
+class EngineCall {
+  constructor(client2, snapshot) {
+    this.client = client2;
+    this.listeners = /* @__PURE__ */ new Map();
+    this.snapshot = snapshot;
+  }
+  get id() {
+    return this.snapshot.id;
+  }
+  get direction() {
+    return this.snapshot.direction;
+  }
+  get data() {
+    var _a2;
+    return {
+      destinationNumber: (_a2 = this.snapshot.contact) == null ? void 0 : _a2.phone,
+      campaignContactPhoneId: this.snapshot.campaignContactPhoneId,
+      answeredAt: this.snapshot.answeredAt ? new Date(this.snapshot.answeredAt) : void 0
+    };
+  }
+  get callerNumber() {
+    var _a2;
+    return (_a2 = this.snapshot.contact) == null ? void 0 : _a2.phone;
+  }
+  get peerDisplayName() {
+    var _a2;
+    return (_a2 = this.snapshot.contact) == null ? void 0 : _a2.name;
+  }
+  get isEstablished() {
+    return this.snapshot.state === "active";
+  }
+  get isEnded() {
+    return this.snapshot.state === "ended";
+  }
+  /** segundos desde o atendimento (ou desde o início, enquanto toca) */
+  get currentDurationSeconds() {
+    const from = this.snapshot.answeredAt ?? this.snapshot.startedAt;
+    return Math.max(0, Math.floor((Date.now() - from) / 1e3));
+  }
+  answer() {
+    this.client.command({ name: "answer" });
+  }
+  reject() {
+    this.client.command({ name: "reject" });
+  }
+  hangup() {
+    this.client.command({ name: "hangup" });
+  }
+  isOnHold() {
+    return { local: false, remote: false };
+  }
+  async hold() {
+  }
+  async unhold() {
+  }
+  isMuted() {
+    return this.client.getState().inputMuted;
+  }
+  mute() {
+    this.client.setInputMuted(true);
+  }
+  unmute() {
+    this.client.setInputMuted(false);
+  }
+  sendDtmf(tones) {
+    this.client.command({ name: "dtmf", tones });
+  }
+  on(event, listener) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(listener);
+    return this;
+  }
+  once(event, listener) {
+    const wrapped = (...args) => {
+      this.off(event, wrapped);
+      listener(...args);
+    };
+    return this.on(event, wrapped);
+  }
+  off(event, listener) {
+    var _a2;
+    (_a2 = this.listeners.get(event)) == null ? void 0 : _a2.delete(listener);
+    return this;
+  }
+  toCallData() {
+    var _a2;
+    return {
+      id: this.snapshot.id,
+      direction: this.snapshot.direction,
+      destinationNumber: ((_a2 = this.snapshot.contact) == null ? void 0 : _a2.phone) ?? "",
+      answeredAt: this.snapshot.answeredAt ? new Date(this.snapshot.answeredAt).toISOString() : void 0,
+      campaignContactPhoneId: this.snapshot.campaignContactPhoneId,
+      isMuted: this.snapshot.muted
+    };
+  }
+}
+function operatorStateFromView(view, call) {
+  var _a2, _b, _c;
+  if (!view) return void 0;
+  if (((_a2 = view.sessionLost) == null ? void 0 : _a2.originator) === "anotherDevice") return { state: "startupError", error: "userIsAlreadyConnectedOnAnotherDevice" };
+  const leg = (_b = view.snapshot) == null ? void 0 : _b.leg;
+  if (!leg) {
+    if (view.engine === "starting") return { state: "starting" };
+    if (view.engine === "running") return { state: "starting" };
+    return { state: "offline" };
+  }
+  const asCall = call ?? void 0;
+  switch (leg.status) {
+    case "starting":
+      return { state: "starting" };
+    case "available":
+      return { state: "idle" };
+    case "ringing":
+      return { state: "callRinging", call: asCall };
+    case "dialing":
+      return ((_c = leg.call) == null ? void 0 : _c.state) === "ringing" ? { state: "manualCallRinging", call: asCall } : { state: "manualCallSetup", call: asCall };
+    case "inCall":
+      return { state: "callInProgress", call: asCall };
+    case "afterCall":
+      return { state: "afterCall" };
+    case "onBreak":
+      return { state: "onBreak", break: ENGINE_BREAKS[0] };
+    case "offline":
+      return { state: "offline" };
+    case "error":
+      return { state: "startupError", error: "unknownError" };
+  }
+}
+function callInfoFromView(view) {
+  var _a2;
+  const leg = (_a2 = view == null ? void 0 : view.snapshot) == null ? void 0 : _a2.leg;
+  const call = leg == null ? void 0 : leg.call;
+  if (!leg || !call) return void 0;
+  const successQualifications = qualificationsFromView(view, "success");
+  const discardQualifications = qualificationsFromView(view, "discard");
+  const contact = call.contact;
+  if (contact == null ? void 0 : contact.campaign) {
+    const info = {
+      campaign: {
+        id: 0,
+        name: contact.campaign,
+        type: 0,
+        requireCallComments: false,
+        enableTransfer: false,
+        enableScheduledCall: false,
+        successQualifications,
+        discardQualifications,
+        previewDuration: "",
+        showCampaignModelOnService: false,
+        skipCallQualification: false
+      },
+      campaignList: { id: 0, name: "" },
+      campaignContact: { id: call.campaignContactPhoneId ?? 0, label: contact.name, phoneNumber: contact.phone }
+    };
+    return { type: "campaign", info };
+  }
+  return { type: "manual", info: { successQualifications, discardQualifications } };
+}
+function useEngineCall(client2) {
+  var _a2, _b;
+  const state = useEngineState(client2);
+  const snapshot = ((_b = (_a2 = state.view) == null ? void 0 : _a2.snapshot) == null ? void 0 : _b.leg.call) ?? null;
+  const ref = useRef(null);
+  if (!snapshot || snapshot.state === "ended") {
+    ref.current = null;
+  } else if (!ref.current || ref.current.id !== snapshot.id) {
+    ref.current = new EngineCall(client2, snapshot);
+  } else {
+    ref.current.snapshot = snapshot;
+  }
+  return ref.current;
+}
+function useEngineOperatorState(client2) {
+  const state = useEngineState(client2);
+  const call = useEngineCall(client2);
+  return useMemo(() => operatorStateFromView(state.view, call), [state.view, call]);
+}
+function useEngineCurrentCall(client2) {
+  const call = useEngineCall(client2);
+  return call ?? void 0;
+}
+function useEngineCurrentCallInfo(client2) {
+  var _a2, _b, _c, _d, _e;
+  const state = useEngineState(client2);
+  const view = state.view;
+  const key = JSON.stringify([(_b = (_a2 = view == null ? void 0 : view.snapshot) == null ? void 0 : _a2.leg.call) == null ? void 0 : _b.id, (_d = (_c = view == null ? void 0 : view.snapshot) == null ? void 0 : _c.leg.call) == null ? void 0 : _d.contact, (_e = view == null ? void 0 : view.snapshot) == null ? void 0 : _e.leg.qualifications]);
+  return useMemo(() => callInfoFromView(view), [key]);
+}
+function useEngineQualifications(client2, kind) {
+  var _a2, _b;
+  const state = useEngineState(client2);
+  const raw = ((_b = (_a2 = state.view) == null ? void 0 : _a2.snapshot) == null ? void 0 : _b.leg.qualifications) ?? [];
+  const key = JSON.stringify(raw);
+  return useMemo(() => qualificationsFromView(state.view, kind), [key, kind]);
+}
+function useEngineControls(client2) {
+  return useMemo(
+    () => ({
+      becomeAvailable: () => {
+        var _a2, _b;
+        const status = (_b = (_a2 = client2.getState().view) == null ? void 0 : _a2.snapshot) == null ? void 0 : _b.leg.status;
+        if (status === "onBreak") client2.command({ name: "resume" });
+      },
+      goOffline: () => void 0,
+      enterOnBreak: () => client2.command({ name: "pause" }),
+      makeManualCall: (phoneNumber) => client2.command({ name: "dial", phone: phoneNumber }),
+      finishAfterCall: (data) => {
+        if (typeof data.qualificationId === "number") client2.command({ name: "qualify", qualificationId: data.qualificationId, result: data.result === "failure" ? "discard" : "success" });
+        else client2.command({ name: "finish" });
+      }
+    }),
+    [client2]
+  );
+}
+function useEngineCurrentCallControls(client2) {
+  return useMemo(
+    () => ({
+      answer: () => client2.command({ name: "answer" }),
+      reject: () => client2.command({ name: "reject" }),
+      hangup: () => client2.command({ name: "hangup" }),
+      isOnHold: () => ({ local: false, remote: false }),
+      hold: async () => void 0,
+      unhold: async () => void 0,
+      isMuted: () => client2.getState().inputMuted,
+      mute: () => client2.setInputMuted(true),
+      unmute: () => client2.setInputMuted(false)
+    }),
+    [client2]
+  );
+}
+function useEngineAudioInputMuted(client2) {
+  const state = useEngineState(client2);
+  const set = useCallback((muted) => client2.setInputMuted(muted), [client2]);
+  return [state.inputMuted, set];
+}
+function useEngineAudioOutputMuted(client2) {
+  const state = useEngineState(client2);
+  const set = useCallback((muted) => client2.setOutputMuted(muted), [client2]);
+  return [state.outputMuted, set];
+}
+function useEngineAudioOutputVolume(client2) {
+  const state = useEngineState(client2);
+  const set = useCallback((volume) => client2.setOutputVolume(volume), [client2]);
+  return [state.outputVolume, set];
+}
+function useEngineEventListener(client2, event, listener) {
+  const ref = useRef(listener);
+  ref.current = listener;
+  useEffect(() => {
+    return client2.onSessionLost((lost) => {
+      ref.current({ originator: lost.originator });
+    });
+  }, [client2, event]);
+}
+const operators = /* @__PURE__ */ new WeakMap();
+function engineOperator(client2) {
+  let operator = operators.get(client2);
+  if (!operator) {
+    const breaks = new EngineSignal(ENGINE_BREAKS);
+    operator = {
+      breaks,
+      user: client2.userSignal,
+      audioOutput: {
+        setAudioOutputDevice: (id) => void client2.setOutputDevice(id).catch(() => void 0),
+        setVolume: (volume) => client2.setOutputVolume(volume),
+        setMute: (muted) => client2.setOutputMuted(muted)
+      },
+      stop: () => void 0,
+      goOffline: () => void 0,
+      becomeAvailable: () => {
+        var _a2, _b;
+        if (((_b = (_a2 = client2.getState().view) == null ? void 0 : _a2.snapshot) == null ? void 0 : _b.leg.status) === "onBreak") client2.command({ name: "resume" });
+      },
+      enterOnBreak: () => client2.command({ name: "pause" }),
+      makeManualCall: (phoneNumber) => client2.command({ name: "dial", phone: phoneNumber }),
+      finishAfterCall: (data) => {
+        if (typeof data.qualificationId === "number") client2.command({ name: "qualify", qualificationId: data.qualificationId, result: data.result === "failure" ? "discard" : "success" });
+        else client2.command({ name: "finish" });
+      }
+    };
+    operators.set(client2, operator);
+  }
+  return operator;
+}
+function useEngineOperator(client2) {
+  return useMemo(() => engineOperator(client2), [client2]);
+}
+function useEngineTranscript(client2) {
+  return useEngineState(client2).transcript;
+}
+function useCallOperator() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineOperator(engine) : clientSdkReactExports.useCallOperator();
+}
+function useCallOperatorState() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineOperatorState(engine) : clientSdkReactExports.useCallOperatorState();
+}
+function useCallOperatorControls() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineControls(engine) : clientSdkReactExports.useCallOperatorControls();
+}
+function useCallOperatorCurrentCall() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineCurrentCall(engine) : clientSdkReactExports.useCallOperatorCurrentCall();
+}
+function useCallOperatorCurrentCallInfo() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineCurrentCallInfo(engine) : clientSdkReactExports.useCallOperatorCurrentCallInfo();
+}
+function useCallOperatorSuccessQualifications() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineQualifications(engine, "success") : clientSdkReactExports.useCallOperatorSuccessQualifications();
+}
+function useCallOperatorDiscardQualifications() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineQualifications(engine, "discard") : clientSdkReactExports.useCallOperatorDiscardQualifications();
+}
+function useCallOperatorCurrentCallControls() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineCurrentCallControls(engine) : clientSdkReactExports.useCallOperatorCurrentCallControls();
+}
+function useCallOperatorAudioInputMuted() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineAudioInputMuted(engine) : clientSdkReactExports.useCallOperatorAudioInputMuted();
+}
+function useCallOperatorAudioOutputMuted() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineAudioOutputMuted(engine) : clientSdkReactExports.useCallOperatorAudioOutputMuted();
+}
+function useCallOperatorAudioOutputVolume() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineAudioOutputVolume(engine) : clientSdkReactExports.useCallOperatorAudioOutputVolume();
+}
+function useCallOperatorEventListener(event, listener) {
+  const engine = useContext(EngineClientContext);
+  if (engine) useEngineEventListener(engine, event, listener);
+  else clientSdkReactExports.useCallOperatorEventListener(event, listener);
+}
 var DefaultContext = {
   color: void 0,
   size: void 0,
@@ -48745,8 +49529,8 @@ function formatPhoneValue(raw) {
 }
 function CallInfoDisplay() {
   var _a2;
-  const callInfo = clientSdkReactExports.useCallOperatorCurrentCallInfo();
-  const currentCall = clientSdkReactExports.useCallOperatorCurrentCall();
+  const callInfo = useCallOperatorCurrentCallInfo();
+  const currentCall = useCallOperatorCurrentCall();
   const campaignContactPhoneId = ((_a2 = currentCall == null ? void 0 : currentCall.data) == null ? void 0 : _a2.campaignContactPhoneId) ?? null;
   if ((callInfo == null ? void 0 : callInfo.type) === "campaign") {
     return /* @__PURE__ */ jsxRuntimeExports.jsx(CampaignCallInfoDisplay, { campaignCallInfo: callInfo.info, campaignContactPhoneId });
@@ -48892,7 +49676,7 @@ function useSignal(signal) {
   return value;
 }
 function useOperatorBreak() {
-  const { enterOnBreak, becomeAvailable } = clientSdkReactExports.useCallOperatorControls();
+  const { enterOnBreak, becomeAvailable } = useCallOperatorControls();
   return {
     // Use the SDK's native method
     goOnBreak: enterOnBreak,
@@ -52189,19 +52973,19 @@ function AuthenticatedDialer({
   const isMiniMode = variant === "min";
   const { skipManualQualification } = useDialerConfig();
   console.log("[FloatingDialer/AuthenticatedDialer] 🔧 skipManualQualification:", skipManualQualification);
-  const operator = clientSdkReactExports.useCallOperator();
-  const operatorState = clientSdkReactExports.useCallOperatorState();
-  const currentCall = clientSdkReactExports.useCallOperatorCurrentCall();
-  const currentCallInfo = clientSdkReactExports.useCallOperatorCurrentCallInfo();
-  const rawSuccessQualifications = clientSdkReactExports.useCallOperatorSuccessQualifications();
-  const rawDiscardQualifications = clientSdkReactExports.useCallOperatorDiscardQualifications();
+  const operator = useCallOperator();
+  const operatorState = useCallOperatorState();
+  const currentCall = useCallOperatorCurrentCall();
+  const currentCallInfo = useCallOperatorCurrentCallInfo();
+  const rawSuccessQualifications = useCallOperatorSuccessQualifications();
+  const rawDiscardQualifications = useCallOperatorDiscardQualifications();
   const successQualifications = useMemo(() => rawSuccessQualifications ?? [], [rawSuccessQualifications]);
   const discardQualifications = useMemo(() => rawDiscardQualifications ?? [], [rawDiscardQualifications]);
-  const { makeManualCall, becomeAvailable, finishAfterCall } = clientSdkReactExports.useCallOperatorControls();
-  const { hangup, answer, reject } = clientSdkReactExports.useCallOperatorCurrentCallControls();
-  const [inputMuted, setInputMuted] = clientSdkReactExports.useCallOperatorAudioInputMuted();
-  const [outputMuted, setOutputMuted] = clientSdkReactExports.useCallOperatorAudioOutputMuted();
-  const [outputVolume, setOutputVolume] = clientSdkReactExports.useCallOperatorAudioOutputVolume();
+  const { makeManualCall, becomeAvailable, finishAfterCall } = useCallOperatorControls();
+  const { hangup, answer, reject } = useCallOperatorCurrentCallControls();
+  const [inputMuted, setInputMuted] = useCallOperatorAudioInputMuted();
+  const [outputMuted, setOutputMuted] = useCallOperatorAudioOutputMuted();
+  const [outputVolume, setOutputVolume] = useCallOperatorAudioOutputVolume();
   useEffect(() => {
     console.log("[FloatingDialer] Estado do operador mudou:", {
       state: operatorState == null ? void 0 : operatorState.state,
@@ -52234,7 +53018,7 @@ function AuthenticatedDialer({
   const visibleInputRef = useRef(null);
   const [callError, setCallError] = useState(null);
   const [availabilityError, setAvailabilityError] = useState(null);
-  clientSdkReactExports.useCallOperatorEventListener("userSessionDropped", (data) => {
+  useCallOperatorEventListener("userSessionDropped", (data) => {
     const notice = describeSessionDrop(data == null ? void 0 : data.originator);
     setAvailabilityError(`${notice.title}: ${notice.detail}${notice.action ? ` ${notice.action}` : ""}`);
   });
@@ -56837,9 +57621,69 @@ function DialerNoticeBanner({ notice, onDismiss, onRecheck, onHeightChange }) {
     dismissible && onDismiss && /* @__PURE__ */ jsxRuntimeExports.jsx("button", { type: "button", className: "dialer-notice-close", onClick: onDismiss, "aria-label": "Fechar aviso", children: /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: "fas fa-xmark", "aria-hidden": "true" }) })
   ] });
 }
+const EMOTION_LABEL = {
+  raiva: "raiva",
+  irritacao: "irritação",
+  frustracao: "frustração",
+  desconfianca: "desconfiança",
+  impaciencia: "impaciência",
+  confusao: "confusão",
+  nervosismo: "nervosismo",
+  surpresa: "surpresa",
+  desanimo: "desânimo",
+  cansaco: "cansaço",
+  interesse: "interesse",
+  entusiasmo: "entusiasmo",
+  satisfacao: "satisfação",
+  alivio: "alívio",
+  neutro: "neutro"
+};
+const STANCE_LABEL = {
+  aberto: "cliente aberto",
+  neutro: "cliente neutro",
+  resistente: "cliente resistente",
+  hostil: "cliente hostil",
+  indefinido: "lendo a conversa"
+};
+const SPEAKER_LABEL = { agent: "Você", customer: "Cliente", mixed: "" };
+function topEmotions(segment, max2 = 2) {
+  return (segment.emotions ?? []).filter((e) => e.label !== "neutro" && e.intensity >= 0.3).slice(0, max2);
+}
+function LiveCaptionPanel({ maxLines = 4 }) {
+  const client2 = useEngineClient();
+  if (!client2) return null;
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(LiveCaptionPanelInner, { client: client2, maxLines });
+}
+function LiveCaptionPanelInner({ client: client2, maxLines }) {
+  const { segments, insight, status } = useEngineTranscript(client2);
+  const listening = (status == null ? void 0 : status.live) === "running";
+  if (segments.length === 0 && !insight && !listening) return null;
+  const rows = segments.slice(-maxLines);
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "live-captions", id: "liveCaptions", "aria-live": "polite", children: [
+    insight && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: `live-insight stance-${insight.customer.stance}`, id: "liveInsight", title: insight.summary, children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "live-insight-stance", children: STANCE_LABEL[insight.customer.stance] ?? insight.customer.stance }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { className: "live-insight-interest", children: [
+        "interesse ",
+        Math.round(insight.customer.interest),
+        "%"
+      ] }),
+      insight.nextMove && /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "live-insight-next", children: insight.nextMove })
+    ] }),
+    rows.length > 0 ? /* @__PURE__ */ jsxRuntimeExports.jsx("ul", { className: "live-caption-list", children: rows.map((segment) => /* @__PURE__ */ jsxRuntimeExports.jsxs("li", { className: `live-caption ${segment.speaker}${segment.interim ? " interim" : ""}${segment.refined ? " refined" : ""}`, children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "live-caption-speaker", children: SPEAKER_LABEL[segment.speaker] }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "live-caption-text", children: segment.text }),
+      topEmotions(segment).map((emotion) => /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { className: `live-caption-emotion${emotion.source === "context" ? " ctx" : ""}`, title: emotion.evidence ?? "", children: [
+        EMOTION_LABEL[emotion.label] ?? emotion.label,
+        " ",
+        Math.round(emotion.intensity * 100),
+        "%"
+      ] }, emotion.label))
+    ] }, segment.id)) }) : /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "live-caption-waiting", children: "Ouvindo a conversa…" })
+  ] });
+}
 function useDialerNotices(options = {}) {
-  const operatorState = clientSdkReactExports.useCallOperatorState();
-  const currentCall = clientSdkReactExports.useCallOperatorCurrentCall();
+  const operatorState = useCallOperatorState();
+  const currentCall = useCallOperatorCurrentCall();
   const [deviceIssue, setDeviceIssue] = useState(null);
   const [sessionDrop, setSessionDrop] = useState(null);
   const [callFailure, setCallFailure] = useState(null);
@@ -56869,7 +57713,7 @@ function useDialerNotices(options = {}) {
       (_a3 = mediaDevices == null ? void 0 : mediaDevices.removeEventListener) == null ? void 0 : _a3.call(mediaDevices, "devicechange", handler);
     };
   }, [options.checkDevices]);
-  clientSdkReactExports.useCallOperatorEventListener("userSessionDropped", (data) => {
+  useCallOperatorEventListener("userSessionDropped", (data) => {
     setSessionDrop((data == null ? void 0 : data.originator) ?? "unknown");
   });
   useEffect(() => {
@@ -57762,21 +58606,21 @@ function AuthenticatedMobileDialer({
   const [speakerDeviceId, setSpeakerDeviceId] = useState(null);
   const [defaultDeviceId, setDefaultDeviceId] = useState("default");
   const [speakerSupported, setSpeakerSupported] = useState(null);
-  const operator = clientSdkReactExports.useCallOperator();
-  const operatorState = clientSdkReactExports.useCallOperatorState();
-  const currentCall = clientSdkReactExports.useCallOperatorCurrentCall();
-  const { hangup, answer, reject } = clientSdkReactExports.useCallOperatorCurrentCallControls();
-  const callInfo = clientSdkReactExports.useCallOperatorCurrentCallInfo();
-  const rawSuccessQualifications = clientSdkReactExports.useCallOperatorSuccessQualifications();
-  const rawDiscardQualifications = clientSdkReactExports.useCallOperatorDiscardQualifications();
+  const operator = useCallOperator();
+  const operatorState = useCallOperatorState();
+  const currentCall = useCallOperatorCurrentCall();
+  const { hangup, answer, reject } = useCallOperatorCurrentCallControls();
+  const callInfo = useCallOperatorCurrentCallInfo();
+  const rawSuccessQualifications = useCallOperatorSuccessQualifications();
+  const rawDiscardQualifications = useCallOperatorDiscardQualifications();
   const successQualifications = useMemo(() => rawSuccessQualifications ?? [], [rawSuccessQualifications]);
   const discardQualifications = useMemo(() => rawDiscardQualifications ?? [], [rawDiscardQualifications]);
-  const { makeManualCall, finishAfterCall } = clientSdkReactExports.useCallOperatorControls();
+  const { makeManualCall, finishAfterCall } = useCallOperatorControls();
   const { goOnBreak, goOffBreak } = useOperatorBreak();
   const breaks = useSignal(operator == null ? void 0 : operator.breaks) || [];
   const userData = useSignal(operator == null ? void 0 : operator.user);
   const isOnBreak = (operatorState == null ? void 0 : operatorState.state) === "onBreak";
-  const [inputMuted, setInputMuted] = clientSdkReactExports.useCallOperatorAudioInputMuted();
+  const [inputMuted, setInputMuted] = useCallOperatorAudioInputMuted();
   const haptic = useHaptic();
   const dtmf = useDTMF({ enabled: true });
   const keySequenceRef = useRef("");
@@ -58595,6 +59439,7 @@ function AuthenticatedMobileDialer({
           ] })
         ] }) })
       ] }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(LiveCaptionPanel, {}),
       /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "call-controls", children: [
         /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "control-row", children: [
           /* @__PURE__ */ jsxRuntimeExports.jsxs(
@@ -59049,14 +59894,14 @@ function AuthenticatedMiniDialer({
 }) {
   var _a2;
   const { skipManualQualification } = useDialerConfig();
-  const operatorState = clientSdkReactExports.useCallOperatorState();
-  const currentCallInfo = clientSdkReactExports.useCallOperatorCurrentCallInfo();
-  const currentCall = clientSdkReactExports.useCallOperatorCurrentCall();
-  const rawSuccessQualifications = clientSdkReactExports.useCallOperatorSuccessQualifications();
-  const rawDiscardQualifications = clientSdkReactExports.useCallOperatorDiscardQualifications();
+  const operatorState = useCallOperatorState();
+  const currentCallInfo = useCallOperatorCurrentCallInfo();
+  const currentCall = useCallOperatorCurrentCall();
+  const rawSuccessQualifications = useCallOperatorSuccessQualifications();
+  const rawDiscardQualifications = useCallOperatorDiscardQualifications();
   const successQualifications = useMemo(() => rawSuccessQualifications ?? [], [rawSuccessQualifications]);
   const discardQualifications = useMemo(() => rawDiscardQualifications ?? [], [rawDiscardQualifications]);
-  const { finishAfterCall } = clientSdkReactExports.useCallOperatorControls();
+  const { finishAfterCall } = useCallOperatorControls();
   const [isClientInfoModalOpen, setIsClientInfoModalOpen] = useState(false);
   const [isQualificationModalOpen, setIsQualificationModalOpen] = useState(false);
   const [callDurationSeconds, setCallDurationSeconds] = useState(0);
@@ -59350,8 +60195,8 @@ function buildHeaders(sessionToken) {
 }
 const delay = (ms2) => new Promise((resolve) => setTimeout(resolve, ms2));
 function ClickToCallAgent({ enabled = true, pollIntervalMs, sessionToken, onTask }) {
-  const operatorState = clientSdkReactExports.useCallOperatorState();
-  const { makeManualCall } = clientSdkReactExports.useCallOperatorControls();
+  const operatorState = useCallOperatorState();
+  const { makeManualCall } = useCallOperatorControls();
   const stateRef = useRef(operatorState == null ? void 0 : operatorState.state);
   stateRef.current = operatorState == null ? void 0 : operatorState.state;
   const makeManualCallRef = useRef(makeManualCall);
@@ -59553,7 +60398,7 @@ function ClickToCallAgent({ enabled = true, pollIntervalMs, sessionToken, onTask
   }, [enabled, pollIntervalMs, sessionToken]);
   return null;
 }
-const WIDGET_VERSION = "2.5.1";
+const WIDGET_VERSION = "2.6.0";
 let currentSipWebSocket = null;
 function sendSipUnregisterIfPossible(ws) {
   if (ws.readyState !== WebSocket.OPEN) return;
@@ -59680,8 +60525,8 @@ function useDialerConfig() {
 }
 const SdkCleanupManager = forwardRef(
   function SdkCleanupManager2({ children: children2 }, ref) {
-    const operator = clientSdkReactExports.useCallOperator();
-    const controls = clientSdkReactExports.useCallOperatorControls();
+    const operator = useCallOperator();
+    const controls = useCallOperatorControls();
     useImperativeHandle(ref, () => ({
       goOffline: () => {
         console.log("[Callix Dialer] 📴 Chamando goOffline() para enviar SIP UNREGISTER...");
@@ -59717,6 +60562,10 @@ const SdkCleanupManager = forwardRef(
 );
 function deriveOptionsFromElement(element) {
   const result2 = {};
+  const datasetEngineUrl = element.getAttribute("data-callix-engine-url") ?? element.dataset.callixEngineUrl;
+  if (datasetEngineUrl && datasetEngineUrl.trim()) result2.engineUrl = datasetEngineUrl.trim();
+  const datasetEngineToken = element.getAttribute("data-callix-engine-token") ?? element.dataset.callixEngineToken;
+  if (datasetEngineToken && datasetEngineToken.trim()) result2.engineToken = datasetEngineToken.trim();
   const datasetMode = element.getAttribute("data-callix-mode") || element.dataset.callixMode || element.dataset.mode;
   const datasetUsername = element.getAttribute("data-callix-username") || element.dataset.callixUsername || element.dataset.username;
   const classList = Array.from(element.classList);
@@ -59808,6 +60657,12 @@ class CallixDialerWidget {
       if (this.options.clickToCall === void 0 && derived.clickToCall !== void 0) {
         this.options.clickToCall = derived.clickToCall;
       }
+      if (!this.options.engineUrl && derived.engineUrl) {
+        this.options.engineUrl = derived.engineUrl;
+      }
+      if (!this.options.engineToken && derived.engineToken) {
+        this.options.engineToken = derived.engineToken;
+      }
       this.root = clientExports.createRoot(this.container);
       this.root.render(
         /* @__PURE__ */ jsxRuntimeExports.jsx(StrictMode, { children: /* @__PURE__ */ jsxRuntimeExports.jsx(DialerWrapper, { options: this.options, containerEl: this.container }) })
@@ -59840,6 +60695,20 @@ const getStorageKeys = (username) => ({
   SKIP_MANUAL_QUALIFICATION: `callix_dialer_${username}_skip_manual_qualification`
 });
 const LAST_USERNAME_KEY = "callix_dialer_last_username";
+async function fetchSkipQualification(domain, token) {
+  var _a2, _b;
+  try {
+    const response = await fetch(`https://${domain}/sdk/v1/client/user-service/config`, {
+      headers: { Authorization: `Bearer ${token}` },
+      credentials: "omit"
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    return ((_b = (_a2 = data == null ? void 0 : data.service) == null ? void 0 : _a2.outboundOptions) == null ? void 0 : _b.skipQualification) === true;
+  } catch {
+    return null;
+  }
+}
 function DialerWrapper({ options, containerEl }) {
   const [username, setUsername] = useState(null);
   const [isAuthenticated, setIsAuthenticated] = useState(false);
@@ -59866,8 +60735,49 @@ function DialerWrapper({ options, containerEl }) {
   useEffect(() => {
     currentSessionRef.current.token = sessionToken;
   }, [sessionToken]);
+  const engineMode = Boolean(options.engineUrl);
+  const engineModeRef = useRef(engineMode);
+  engineModeRef.current = engineMode;
+  const engineRef = useRef(null);
+  const ensureEngine = useCallback(
+    (user) => {
+      const current = engineRef.current;
+      if (current && current.agentId === user) {
+        current.connect();
+        return current;
+      }
+      current == null ? void 0 : current.close();
+      const client2 = new EngineClient({
+        url: options.engineUrl ?? "",
+        token: options.engineToken ?? "",
+        agentId: user,
+        label: "Discador",
+        log: (message) => console.log("[Callix Dialer/motor]", message)
+      });
+      client2.onSessionLost((lost) => {
+        const notice = describeSessionDrop(lost.originator);
+        setError(`${notice.title}: ${notice.detail}${notice.action ? ` ${notice.action}` : ""}`);
+        setIsAuthenticated(false);
+        setSessionToken(null);
+        autoLoginAttemptedRef.current = true;
+      });
+      client2.connect();
+      engineRef.current = client2;
+      return client2;
+    },
+    [options.engineUrl, options.engineToken]
+  );
+  useEffect(
+    () => () => {
+      var _a2;
+      (_a2 = engineRef.current) == null ? void 0 : _a2.close();
+      engineRef.current = null;
+    },
+    []
+  );
   useEffect(() => {
     const handleBeforeUnload = () => {
+      if (engineModeRef.current) return;
       const { apiUrl, token } = currentSessionRef.current;
       if (token) {
         const data = JSON.stringify({ logout: true });
@@ -59932,6 +60842,77 @@ function DialerWrapper({ options, containerEl }) {
     setError(null);
     setLoginStatus("Preparando login...");
     console.log("[Callix Dialer] 🚀 handleLogin iniciado para usuário:", user);
+    if (options.engineUrl) {
+      const engineApiUrl = options.apiUrl || "/api/user-sdk-session";
+      try {
+        setLoginStatus("Conectando ao motor...");
+        const client2 = ensureEngine(user);
+        const view = await client2.waitForView(15e3);
+        const domain = options.domain || new URL(engineApiUrl, window.location.href).host;
+        const engineHasSession = (view.engine === "running" || view.engine === "starting") && !view.sessionLost;
+        let token = null;
+        if (engineHasSession) {
+          try {
+            token = localStorage.getItem(getStorageKeys(user).SESSION_TOKEN);
+          } catch {
+            token = null;
+          }
+          console.log("[Callix Dialer] motor já tem a sessão do agente; entrando sem novo login");
+        } else {
+          setLoginStatus("Autenticando no Callix...");
+          const response = await fetch(engineApiUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ username: user }),
+            credentials: "same-origin"
+          });
+          if (!response.ok) {
+            const errorData = await response.json().catch(() => ({ error: "Erro desconhecido" }));
+            throw new Error(errorData.error || `Falha na autenticação: ${response.status}`);
+          }
+          const data = await response.json();
+          token = data.userSessionToken;
+          client2.setSession({ domain, userSessionToken: token });
+          setLoginStatus("Subindo o motor...");
+        }
+        if (token) {
+          const skip = await fetchSkipQualification(domain, token);
+          if (skip !== null) {
+            setSkipManualQualification(skip);
+            try {
+              localStorage.setItem(getStorageKeys(user).SKIP_MANUAL_QUALIFICATION, String(skip));
+            } catch {
+            }
+          }
+        }
+        try {
+          localStorage.setItem(LAST_USERNAME_KEY, user);
+          if (token) {
+            const STORAGE_KEYS = getStorageKeys(user);
+            localStorage.setItem(STORAGE_KEYS.SESSION_TOKEN, token);
+            localStorage.setItem(STORAGE_KEYS.DOMAIN, domain);
+            localStorage.setItem(STORAGE_KEYS.TIMESTAMP, Date.now().toString());
+          }
+        } catch {
+        }
+        setSessionToken(token);
+        setCallixDomain(domain);
+        setUsername(user);
+        setIsAuthenticated(true);
+        setError(null);
+        setProviderKey(Date.now());
+        console.log("[Callix Dialer] Conectado ao motor como", user);
+      } catch (err) {
+        console.error("[Callix Dialer] Erro ao entrar pelo motor:", err);
+        setError(err instanceof Error ? err.message : "Erro ao conectar ao motor");
+        setIsAuthenticated(false);
+        setSessionToken(null);
+      } finally {
+        setIsLoading(false);
+        setLoginStatus(null);
+      }
+      return;
+    }
     const apiUrl = options.apiUrl || "/api/user-sdk-session";
     let previousToken;
     if (typeof window !== "undefined") {
@@ -60078,7 +61059,7 @@ function DialerWrapper({ options, containerEl }) {
       setIsLoading(false);
       setLoginStatus(null);
     }
-  }, [options.apiUrl, options.domain, isAuthenticated, sessionToken]);
+  }, [options.apiUrl, options.domain, options.engineUrl, isAuthenticated, sessionToken, ensureEngine]);
   useEffect(() => {
     if (lastPresetRef.current !== presetUsername) {
       lastPresetRef.current = presetUsername;
@@ -60102,8 +61083,11 @@ function DialerWrapper({ options, containerEl }) {
     void handleLogin(username);
   }, [autoLogin, presetUsername, username, isAuthenticated, isLoading, isRestoringSession, error2, handleLogin]);
   const handleLogout = useCallback(async () => {
+    var _a2;
     const currentUsername = username;
-    if (cleanupRef.current) {
+    if (options.engineUrl) {
+      (_a2 = engineRef.current) == null ? void 0 : _a2.command({ name: "logoff" });
+    } else if (cleanupRef.current) {
       console.log("[Callix Dialer] 📴 Logout: Chamando goOffline()...");
       cleanupRef.current.goOffline();
       await new Promise((resolve) => setTimeout(resolve, 500));
@@ -60130,7 +61114,7 @@ function DialerWrapper({ options, containerEl }) {
         console.warn("[Callix Dialer] Não foi possível limpar sessão:", err);
       }
     }
-  }, [username, presetUsername]);
+  }, [username, presetUsername, options.engineUrl]);
   const pendingAutoLogin = autoLogin && Boolean(username) && !isAuthenticated && !error2 && !autoLoginAttemptedRef.current;
   const loginConfirmation = useMemo(() => {
     if (isAuthenticated || isLoading || isRestoringSession || isDisconnecting || !username || pendingAutoLogin) {
@@ -60169,7 +61153,7 @@ function DialerWrapper({ options, containerEl }) {
       }
     ) });
   }
-  if (!isAuthenticated || !sessionToken || !callixDomain) {
+  if (!isAuthenticated || !engineMode && (!sessionToken || !callixDomain)) {
     return /* @__PURE__ */ jsxRuntimeExports.jsx(DialerConfigContext.Provider, { value: { skipManualQualification }, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
       DialerComponent,
       {
@@ -60189,6 +61173,38 @@ function DialerWrapper({ options, containerEl }) {
       }
     ) });
   }
+  if (engineMode && engineRef.current) {
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(DialerConfigContext.Provider, { value: { skipManualQualification }, children: /* @__PURE__ */ jsxRuntimeExports.jsxs(EngineClientProvider, { client: engineRef.current, children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        DialerComponent,
+        {
+          isAuthenticated,
+          username,
+          onLogin: handleLogin,
+          onLogout: handleLogout,
+          isLoadingSession: isLoading,
+          sessionError: error2,
+          sessionStatus: loginStatus,
+          variant: uiVariant,
+          portalTarget,
+          density: options.density,
+          mode: dialerMode
+        }
+      ),
+      sessionToken && /* @__PURE__ */ jsxRuntimeExports.jsx(
+        ClickToCallAgent,
+        {
+          enabled: clickToCall.enabled,
+          pollIntervalMs: clickToCall.pollIntervalMs,
+          sessionToken,
+          onTask: clickToCall.onTask
+        }
+      )
+    ] }, providerKey) });
+  }
+  if (!sessionToken || !callixDomain) {
+    return null;
+  }
   return /* @__PURE__ */ jsxRuntimeExports.jsx(DialerConfigContext.Provider, { value: { skipManualQualification }, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
     clientSdkReactExports.CallixClientProvider,
     {