1309 lines
37 KiB
JavaScript
1309 lines
37 KiB
JavaScript
const cfg = window.EB_CONCIERGE || {};
|
|
const botId = cfg.botId;
|
|
const apiBase = String(cfg.apiBase || '').replace(/\/$/, '');
|
|
const Livekit = window.LivekitClient || window.livekit;
|
|
|
|
const videoEl = document.getElementById('eba-video');
|
|
// const audioEl = document.getElementById('eba-audio');
|
|
// const waveEl = document.getElementById('eba-wave');
|
|
const audioEl = document.getElementById('eba-audio');
|
|
const avatarStageEl = document.getElementById('eba-avatar-stage');
|
|
const messagesEl = document.getElementById('eba-messages');
|
|
const errorEl = document.getElementById('eba-error');
|
|
const formEl = document.getElementById('eba-form');
|
|
const inputEl = document.getElementById('eba-input');
|
|
const sendBtn = document.getElementById('eba-send');
|
|
const startBtn = document.getElementById('eba-start');
|
|
const startHintEl = document.getElementById('eba-start-hint');
|
|
const statusEl = document.getElementById('eba-avatar-status');
|
|
const titleEl = document.getElementById('eba-title');
|
|
const subEl = document.getElementById('eba-sub');
|
|
|
|
let sessionId = null;
|
|
let busy = false;
|
|
let livekitRoom = null;
|
|
// let simliClient = null;
|
|
let started = false;
|
|
let chatReady = false;
|
|
// let pipedTrackId = null;
|
|
let seenTranscriptIds = {};
|
|
let chipsEl = null;
|
|
const mutedLivekitAudioEls = [];
|
|
let pendingGreeting = '';
|
|
let pendingQuickReplies = [];
|
|
let greetingShown = false;
|
|
let avatarReadySent = false;
|
|
let lastAgentMediaTrack = null;
|
|
// let lastAgentTrackClone = null;
|
|
let sessionAlive = false;
|
|
// let simliRestarting = false;
|
|
// let simliIdle = false;
|
|
// let simliGeneration = 0;
|
|
let videoAvatarOn = false;
|
|
let waveAudioCtx = null;
|
|
let userAnalyser = null;
|
|
let agentAnalyser = null;
|
|
let avatarAudioSource = null;
|
|
let avatarAudioAnalyser = null;
|
|
let waveRaf = 0;
|
|
// let simliInputEnabled = false;
|
|
let agentPipelineState = '';
|
|
let micListening = true;
|
|
let micPublished = false;
|
|
let micResumeTimer = 0;
|
|
// const SIMLI_AUDIO_BUFFER = 3000;
|
|
const AGENT_STATE_ATTR = 'lk.agent.state';
|
|
|
|
function setStatus(text) {
|
|
statusEl.textContent = text || '';
|
|
}
|
|
|
|
function setError(text) {
|
|
const msg = String(text || '').trim();
|
|
errorEl.hidden = !msg;
|
|
errorEl.textContent = msg;
|
|
}
|
|
|
|
function showStartOverlay(label, hint) {
|
|
startBtn.hidden = false;
|
|
const title = startBtn.querySelector('.eba-start-title');
|
|
if (title) title.textContent = label || 'Tap to start';
|
|
if (startHintEl) startHintEl.textContent = hint || '';
|
|
}
|
|
|
|
function hideStartOverlay() {
|
|
startBtn.hidden = true;
|
|
if (startHintEl) startHintEl.textContent = '';
|
|
}
|
|
|
|
function el(tag, attrs, children) {
|
|
const n = document.createElement(tag);
|
|
if (attrs) {
|
|
Object.keys(attrs).forEach((k) => n.setAttribute(k, attrs[k]));
|
|
}
|
|
(children || []).forEach((c) => {
|
|
n.appendChild(typeof c === 'string' ? document.createTextNode(c) : c);
|
|
});
|
|
return n;
|
|
}
|
|
|
|
function appendFormattedText(parent, text) {
|
|
const s = String(text || '');
|
|
const re = /\*\*([^*]+)\*\*/g;
|
|
let last = 0;
|
|
let m;
|
|
while ((m = re.exec(s))) {
|
|
if (m.index > last) parent.appendChild(document.createTextNode(s.slice(last, m.index)));
|
|
parent.appendChild(el('strong', null, [m[1]]));
|
|
last = m.index + m[0].length;
|
|
}
|
|
if (last < s.length) parent.appendChild(document.createTextNode(s.slice(last)));
|
|
return parent;
|
|
}
|
|
|
|
function addMessage(role, text, opts = {}) {
|
|
const bubble = el('div', { class: `eba-msg ${role === 'user' ? 'user' : 'bot'}` });
|
|
if (text) {
|
|
const intro = el('div');
|
|
appendFormattedText(intro, text);
|
|
bubble.appendChild(intro);
|
|
}
|
|
const cards = Array.isArray(opts.cards) ? opts.cards : [];
|
|
if (cards.length) {
|
|
const list = el('div', { class: 'eba-cards' });
|
|
cards.forEach((card) => {
|
|
const node = renderCard(card);
|
|
if (node) list.appendChild(node);
|
|
});
|
|
if (list.childNodes.length) bubble.appendChild(list);
|
|
}
|
|
if (opts.messageId && role !== 'user') {
|
|
bubble.appendChild(buildFeedback(String(opts.messageId)));
|
|
}
|
|
messagesEl.appendChild(bubble);
|
|
messagesEl.scrollTop = messagesEl.scrollHeight;
|
|
return bubble;
|
|
}
|
|
|
|
function renderCard(card) {
|
|
if (!card) return null;
|
|
const d = card.data || {};
|
|
const type = card.type;
|
|
const wrap = el('article', { class: 'eba-card' });
|
|
|
|
if (type === 'cta' && d.url) {
|
|
wrap.appendChild(
|
|
el(
|
|
'a',
|
|
{ href: String(d.url), target: '_blank', rel: 'noopener noreferrer' },
|
|
[String(d.actionLabel || d.title || 'Open')],
|
|
),
|
|
);
|
|
return wrap;
|
|
}
|
|
|
|
if (type === 'ticket_qr') {
|
|
wrap.appendChild(el('div', { class: 'eba-card-title' }, [d.name || d.ticketName || 'Ticket']));
|
|
if (d.status) wrap.appendChild(el('div', { class: 'eba-card-meta' }, [String(d.status)]));
|
|
const img = d.qrImageUrl || d.imageUrl;
|
|
if (img) wrap.appendChild(el('img', { src: String(img), alt: 'Check-in QR' }));
|
|
return wrap;
|
|
}
|
|
|
|
if (type === 'file') {
|
|
const title = String(d.title || 'Download').trim() || 'Download';
|
|
wrap.appendChild(el('div', { class: 'eba-card-title' }, [title]));
|
|
if (d.url) {
|
|
wrap.appendChild(
|
|
el('a', { href: String(d.url), target: '_blank', rel: 'noopener noreferrer' }, ['Open']),
|
|
);
|
|
}
|
|
return wrap;
|
|
}
|
|
|
|
const title = d.title || d.name;
|
|
if (title) wrap.appendChild(el('div', { class: 'eba-card-title' }, [String(title)]));
|
|
const meta = [
|
|
d.timeRangeLocal,
|
|
d.location,
|
|
d.track,
|
|
d.booth,
|
|
d.address,
|
|
d.organization || d.organizationName,
|
|
d.speakerRole,
|
|
]
|
|
.filter(Boolean)
|
|
.join(' · ');
|
|
if (meta) wrap.appendChild(el('div', { class: 'eba-card-meta' }, [meta]));
|
|
if (Array.isArray(d.speakers) && d.speakers.length) {
|
|
wrap.appendChild(
|
|
el('div', { class: 'eba-card-meta' }, [`Speakers: ${d.speakers.slice(0, 4).join(', ')}`]),
|
|
);
|
|
}
|
|
const href = d.url || d.mapsUrl || d.website;
|
|
if (href) {
|
|
wrap.appendChild(
|
|
el('a', { href: String(href), target: '_blank', rel: 'noopener noreferrer' }, [
|
|
d.mapsUrl ? 'Open map' : 'Open',
|
|
]),
|
|
);
|
|
}
|
|
return wrap.childNodes.length ? wrap : null;
|
|
}
|
|
|
|
function buildFeedback(messageId) {
|
|
const footer = el('div', { class: 'eba-feedback' }, ['Was this useful?']);
|
|
const up = el('button', { type: 'button', 'aria-label': 'Yes' }, ['👍']);
|
|
const down = el('button', { type: 'button', 'aria-label': 'No' }, ['👎']);
|
|
const send = async (satisfied) => {
|
|
up.disabled = true;
|
|
down.disabled = true;
|
|
try {
|
|
await api(`/public/concierge/${encodeURIComponent(botId)}/feedback`, {
|
|
method: 'POST',
|
|
body: { sessionId, messageId, satisfied },
|
|
});
|
|
} catch {
|
|
/* ignore */
|
|
}
|
|
};
|
|
up.addEventListener('click', () => send(true));
|
|
down.addEventListener('click', () => send(false));
|
|
footer.appendChild(up);
|
|
footer.appendChild(down);
|
|
return footer;
|
|
}
|
|
|
|
function renderChips(items) {
|
|
if (chipsEl && chipsEl.parentNode) chipsEl.parentNode.removeChild(chipsEl);
|
|
chipsEl = null;
|
|
const rows = Array.isArray(items) ? items : [];
|
|
if (!rows.length) return;
|
|
chipsEl = el('div', { class: 'eba-chips' });
|
|
rows.slice(0, 6).forEach((item) => {
|
|
const label = String(item.label || item.message || '').trim();
|
|
if (!label) return;
|
|
const btn = el('button', { class: 'eba-chip', type: 'button' }, [label]);
|
|
btn.addEventListener('click', () => {
|
|
if (busy) return;
|
|
inputEl.value = String(item.message || label);
|
|
sendMessage();
|
|
});
|
|
chipsEl.appendChild(btn);
|
|
});
|
|
if (!chipsEl.childNodes.length) {
|
|
chipsEl = null;
|
|
return;
|
|
}
|
|
messagesEl.appendChild(chipsEl);
|
|
messagesEl.scrollTop = messagesEl.scrollHeight;
|
|
}
|
|
|
|
function normalizeSpeech(text) {
|
|
return String(text || '')
|
|
.replace(/\*\*([^*]+)\*\*/g, '$1')
|
|
.replace(/\s+/g, ' ')
|
|
.trim()
|
|
.toLowerCase();
|
|
}
|
|
|
|
function showPendingGreeting() {
|
|
if (greetingShown) return;
|
|
greetingShown = true;
|
|
if (pendingGreeting) addMessage('bot', pendingGreeting);
|
|
if (pendingQuickReplies.length) renderChips(pendingQuickReplies);
|
|
}
|
|
|
|
async function signalAvatarReady(room) {
|
|
if (avatarReadySent || !room?.localParticipant) return;
|
|
avatarReadySent = true;
|
|
showPendingGreeting();
|
|
const payload = new TextEncoder().encode(JSON.stringify({ type: 'avatar-ready' }));
|
|
const send = async () => {
|
|
try {
|
|
if (typeof room.localParticipant.publishData === 'function') {
|
|
await room.localParticipant.publishData(payload, { reliable: true });
|
|
console.log('[DEBUG] avatar-ready SENT', {
|
|
identity: room.localParticipant.identity,
|
|
room: room.name,
|
|
});
|
|
}
|
|
} catch (err) {
|
|
console.warn('[avatar] ready signal failed', err);
|
|
}
|
|
};
|
|
await send();
|
|
setTimeout(send, 1500);
|
|
}
|
|
|
|
function rememberTranscript(id) {
|
|
if (!id) return false;
|
|
if (seenTranscriptIds[id]) return true;
|
|
seenTranscriptIds[id] = true;
|
|
return false;
|
|
}
|
|
|
|
async function api(path, options) {
|
|
const hasBody = options?.body !== undefined;
|
|
const res = await fetch(apiBase + path, {
|
|
method: options?.method || 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
...(hasBody ? { 'Content-Type': 'application/json' } : {}),
|
|
},
|
|
body: hasBody ? JSON.stringify(options.body) : undefined,
|
|
});
|
|
const json = await res.json().catch(() => null);
|
|
if (!res.ok || !json || json.success === false) {
|
|
const msg = json?.error?.message || json?.message || `Request failed (${res.status})`;
|
|
throw new Error(msg);
|
|
}
|
|
return json.data;
|
|
}
|
|
|
|
function setBusy(next) {
|
|
busy = next;
|
|
inputEl.disabled = next;
|
|
sendBtn.disabled = next;
|
|
}
|
|
|
|
async function sendMessage() {
|
|
const text = String(inputEl.value || '').trim();
|
|
if (!text || busy) return;
|
|
setError('');
|
|
inputEl.value = '';
|
|
renderChips([]);
|
|
addMessage('user', text);
|
|
// ensureSimliConnected('chat');
|
|
setBusy(true);
|
|
try {
|
|
const data = await api(`/public/concierge/${encodeURIComponent(botId)}/chat`, {
|
|
method: 'POST',
|
|
body: { message: text, sessionId: sessionId || undefined },
|
|
});
|
|
sessionId = data.sessionId || sessionId;
|
|
addMessage('bot', data.reply || 'No reply', {
|
|
cards: data.cards || [],
|
|
messageId: data.messageId || null,
|
|
});
|
|
if (Array.isArray(data.quickReplies) && data.quickReplies.length) {
|
|
renderChips(data.quickReplies);
|
|
}
|
|
} catch (err) {
|
|
setError(err.message || 'Failed to send');
|
|
} finally {
|
|
setBusy(false);
|
|
inputEl.focus();
|
|
}
|
|
}
|
|
|
|
function mediaTrackFrom(livekitTrack) {
|
|
if (!livekitTrack) return null;
|
|
return livekitTrack.mediaStreamTrack || livekitTrack.mediaStream?.getAudioTracks?.()[0] || null;
|
|
}
|
|
|
|
function isLocalParticipant(room, participant) {
|
|
if (!room || !participant) return false;
|
|
const local = room.localParticipant;
|
|
if (local && (participant === local || (local.sid && participant.sid === local.sid))) {
|
|
return true;
|
|
}
|
|
const localId = local?.identity;
|
|
return Boolean(localId && participant.identity === localId);
|
|
}
|
|
|
|
function stopAgentTrackClone() {
|
|
if (lastAgentTrackClone && typeof lastAgentTrackClone.stop === 'function') {
|
|
try {
|
|
lastAgentTrackClone.stop();
|
|
} catch {
|
|
/* ignore */
|
|
}
|
|
}
|
|
lastAgentTrackClone = null;
|
|
}
|
|
|
|
function unmuteSimliPlayback() {
|
|
if (!audioEl) return;
|
|
audioEl.muted = false;
|
|
audioEl.defaultMuted = false;
|
|
audioEl.volume = 1;
|
|
audioEl.removeAttribute('muted');
|
|
}
|
|
|
|
function parseAgentStatePayload(raw) {
|
|
try {
|
|
const msg = JSON.parse(typeof raw === 'string' ? raw : new TextDecoder().decode(raw));
|
|
if (msg && msg.type === 'agent-state' && msg.state) return String(msg.state).toLowerCase();
|
|
} catch {
|
|
/* ignore */
|
|
}
|
|
return '';
|
|
}
|
|
|
|
function readRemoteAgentState(room) {
|
|
let state = '';
|
|
room?.remoteParticipants?.forEach((p) => {
|
|
if (!p || isLocalParticipant(room, p)) return;
|
|
const value = p.attributes?.[AGENT_STATE_ATTR];
|
|
if (value) state = String(value).toLowerCase();
|
|
});
|
|
return state;
|
|
}
|
|
|
|
function disconnectSimliTts() {
|
|
const src = simliClient?.sourceNode;
|
|
if (src && typeof src.disconnect === 'function') {
|
|
try {
|
|
src.disconnect();
|
|
} catch {
|
|
/* ignore */
|
|
}
|
|
}
|
|
if (simliClient) simliClient.sourceNode = null;
|
|
stopAgentTrackClone();
|
|
simliInputEnabled = false;
|
|
pipedTrackId = null;
|
|
}
|
|
|
|
function connectSimliTts(media) {
|
|
if (!videoAvatarOn || !media || !simliClient || typeof simliClient.listenToMediastreamTrack !== 'function') {
|
|
return;
|
|
}
|
|
if (simliIdle) {
|
|
ensureSimliConnected('agent-tts');
|
|
return;
|
|
}
|
|
const id = media.id || media.label;
|
|
if (simliInputEnabled && pipedTrackId && pipedTrackId === id) return;
|
|
disconnectSimliTts();
|
|
try {
|
|
const clone = typeof media.clone === 'function' ? media.clone() : media;
|
|
lastAgentTrackClone = clone;
|
|
if (clone) clone.enabled = true;
|
|
simliClient.listenToMediastreamTrack(clone);
|
|
simliInputEnabled = true;
|
|
pipedTrackId = id;
|
|
} catch (err) {
|
|
console.warn('[avatar] simli tts pipe failed', err);
|
|
}
|
|
}
|
|
|
|
async function setMicListening(on) {
|
|
const next = Boolean(on);
|
|
if (micResumeTimer) {
|
|
clearTimeout(micResumeTimer);
|
|
micResumeTimer = 0;
|
|
}
|
|
if (!micPublished || !livekitRoom?.localParticipant) {
|
|
micListening = next;
|
|
return;
|
|
}
|
|
if (micListening === next) return;
|
|
micListening = next;
|
|
try {
|
|
if (typeof livekitRoom.localParticipant.setMicrophoneEnabled === 'function') {
|
|
await livekitRoom.localParticipant.setMicrophoneEnabled(next);
|
|
}
|
|
} catch (err) {
|
|
console.warn('[avatar] mic toggle failed', err);
|
|
}
|
|
}
|
|
|
|
function applyAgentState(state) {
|
|
const next = String(state || '').toLowerCase();
|
|
if (!next) return;
|
|
|
|
agentPipelineState = next;
|
|
|
|
const speaking = next === 'speaking';
|
|
const holdMic = speaking || next === 'thinking';
|
|
|
|
if (holdMic) {
|
|
setMicListening(false);
|
|
} else {
|
|
micResumeTimer = window.setTimeout(
|
|
() => setMicListening(true),
|
|
700
|
|
);
|
|
}
|
|
|
|
if (next === 'thinking') {
|
|
setStatus('Thinking');
|
|
} else if (speaking) {
|
|
setStatus('Speaking');
|
|
} else {
|
|
setStatus('Listening');
|
|
}
|
|
}
|
|
|
|
function makeSimliClient(SimliClient, LogLevel, token) {
|
|
return new SimliClient(
|
|
token,
|
|
videoEl,
|
|
audioEl,
|
|
null,
|
|
LogLevel?.INFO ?? 1,
|
|
'livekit',
|
|
'websockets',
|
|
'wss://api.simli.ai',
|
|
SIMLI_AUDIO_BUFFER,
|
|
);
|
|
}
|
|
|
|
function attachRemoteAudio(track, audible) {
|
|
if (!track || typeof track.attach !== 'function') return;
|
|
try {
|
|
const node = track.attach();
|
|
if (!node) return;
|
|
node.muted = !audible;
|
|
node.volume = audible ? 1 : 0;
|
|
node.autoplay = true;
|
|
node.playsInline = true;
|
|
node.style.position = 'absolute';
|
|
node.style.width = '1px';
|
|
node.style.height = '1px';
|
|
node.style.opacity = '0';
|
|
node.style.pointerEvents = 'none';
|
|
document.body.appendChild(node);
|
|
mutedLivekitAudioEls.push(node);
|
|
if (audible && node.play) node.play().catch(() => {});
|
|
} catch {
|
|
/* ignore */
|
|
}
|
|
}
|
|
|
|
function unmuteLivekitFallback() {
|
|
mutedLivekitAudioEls.forEach((node) => {
|
|
try {
|
|
node.muted = false;
|
|
node.volume = 1;
|
|
if (node.play) node.play().catch(() => {});
|
|
} catch {
|
|
/* ignore */
|
|
}
|
|
});
|
|
}
|
|
|
|
function muteLivekitPlayback() {
|
|
mutedLivekitAudioEls.forEach((node) => {
|
|
try {
|
|
node.muted = true;
|
|
node.volume = 0;
|
|
} catch {
|
|
/* ignore */
|
|
}
|
|
});
|
|
}
|
|
|
|
function parseAccentRgb() {
|
|
const raw = getComputedStyle(document.documentElement).getPropertyValue('--eba-accent').trim();
|
|
const m = raw.match(/(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
|
|
if (m) return { r: Number(m[1]), g: Number(m[2]), b: Number(m[3]) };
|
|
return { r: 13, g: 148, b: 136 };
|
|
}
|
|
|
|
function ensureWaveAudioCtx() {
|
|
if (!waveAudioCtx) {
|
|
const Ctx = window.AudioContext || window.webkitAudioContext;
|
|
if (!Ctx) return null;
|
|
waveAudioCtx = new Ctx();
|
|
}
|
|
if (waveAudioCtx.state === 'suspended') waveAudioCtx.resume().catch(() => {});
|
|
return waveAudioCtx;
|
|
}
|
|
function hookAvatarAnalyser(mediaTrack) {
|
|
if (!mediaTrack) {
|
|
return;
|
|
}
|
|
|
|
const ctx = ensureWaveAudioCtx();
|
|
|
|
if (!ctx) {
|
|
console.warn(
|
|
'[avatar3d] AudioContext unavailable'
|
|
);
|
|
return;
|
|
}
|
|
|
|
try {
|
|
if (avatarAudioSource) {
|
|
try {
|
|
avatarAudioSource.disconnect();
|
|
} catch {
|
|
// ignore
|
|
}
|
|
|
|
avatarAudioSource = null;
|
|
}
|
|
|
|
const clone =
|
|
typeof mediaTrack.clone === 'function'
|
|
? mediaTrack.clone()
|
|
: mediaTrack;
|
|
|
|
const stream =
|
|
new MediaStream([clone]);
|
|
|
|
avatarAudioSource =
|
|
ctx.createMediaStreamSource(
|
|
stream
|
|
);
|
|
|
|
avatarAudioAnalyser =
|
|
ctx.createAnalyser();
|
|
|
|
avatarAudioAnalyser.fftSize = 256;
|
|
|
|
avatarAudioAnalyser.smoothingTimeConstant = 0.72;
|
|
|
|
avatarAudioSource.connect(
|
|
avatarAudioAnalyser
|
|
);
|
|
|
|
if (
|
|
window.EBAvatar3D &&
|
|
typeof window.EBAvatar3D.setAudioAnalyser ===
|
|
'function'
|
|
) {
|
|
window.EBAvatar3D.setAudioAnalyser(
|
|
avatarAudioAnalyser
|
|
);
|
|
}
|
|
|
|
console.info(
|
|
'[avatar3d] agent audio connected to avatar'
|
|
);
|
|
} catch (err) {
|
|
console.warn(
|
|
'[avatar3d] audio analyser failed',
|
|
err
|
|
);
|
|
}
|
|
}
|
|
|
|
function hookWaveAnalyser(mediaTrack, slot) {
|
|
if (!mediaTrack || videoAvatarOn) return;
|
|
|
|
const ctx = ensureWaveAudioCtx();
|
|
if (!ctx) return;
|
|
|
|
try {
|
|
const clone =
|
|
typeof mediaTrack.clone === 'function'
|
|
? mediaTrack.clone()
|
|
: mediaTrack;
|
|
|
|
const source = ctx.createMediaStreamSource(
|
|
new MediaStream([clone])
|
|
);
|
|
|
|
const analyser = ctx.createAnalyser();
|
|
analyser.fftSize = 256;
|
|
analyser.smoothingTimeConstant = 0.72;
|
|
|
|
source.connect(analyser);
|
|
|
|
if (slot === 'user') {
|
|
userAnalyser = analyser;
|
|
} else {
|
|
agentAnalyser = analyser;
|
|
}
|
|
} catch (err) {
|
|
console.warn('[avatar] wave analyser failed', err);
|
|
}
|
|
}
|
|
|
|
function analyserSnapshot(analyser) {
|
|
if (!analyser) return { rms: 0, bins: null };
|
|
const bins = new Uint8Array(analyser.frequencyBinCount);
|
|
analyser.getByteFrequencyData(bins);
|
|
let sum = 0;
|
|
for (let i = 0; i < bins.length; i += 1) sum += bins[i] * bins[i];
|
|
return { rms: Math.sqrt(sum / bins.length) / 255, bins };
|
|
}
|
|
|
|
function stopWaveLoop() {
|
|
if (waveRaf) {
|
|
cancelAnimationFrame(waveRaf);
|
|
waveRaf = 0;
|
|
}
|
|
}
|
|
|
|
function startWaveLoop() {
|
|
if (!waveEl || videoAvatarOn || waveRaf) return;
|
|
const canvas = waveEl;
|
|
const ctx2d = canvas.getContext('2d');
|
|
if (!ctx2d) return;
|
|
|
|
const draw = () => {
|
|
waveRaf = requestAnimationFrame(draw);
|
|
const w = canvas.clientWidth || 1;
|
|
const h = canvas.clientHeight || 1;
|
|
if (canvas.width !== w || canvas.height !== h) {
|
|
canvas.width = w;
|
|
canvas.height = h;
|
|
}
|
|
const user = analyserSnapshot(userAnalyser);
|
|
const agent = analyserSnapshot(agentAnalyser);
|
|
const accent = parseAccentRgb();
|
|
const t = Date.now() / 1000;
|
|
const idle = 0.1 + 0.04 * Math.sin(t * 2.2);
|
|
const userRms = Math.max(user.rms, 0);
|
|
const agentRms = Math.max(agent.rms, 0);
|
|
const level = Math.max(userRms, agentRms, idle * 0.35);
|
|
const agentLead = agentRms >= userRms;
|
|
const bins = (agentLead ? agent.bins : user.bins) || new Uint8Array(32);
|
|
const barCount = 36;
|
|
ctx2d.clearRect(0, 0, w, h);
|
|
const bg = ctx2d.createRadialGradient(w / 2, h / 2, 20, w / 2, h / 2, Math.max(w, h) * 0.55);
|
|
bg.addColorStop(0, `rgba(${accent.r},${accent.g},${accent.b},${0.12 + level * 0.28})`);
|
|
bg.addColorStop(1, 'rgba(2,6,23,0)');
|
|
ctx2d.fillStyle = bg;
|
|
ctx2d.fillRect(0, 0, w, h);
|
|
|
|
const cx = w / 2;
|
|
const cy = h / 2;
|
|
const radius = Math.min(w, h) * 0.16;
|
|
ctx2d.beginPath();
|
|
ctx2d.arc(cx, cy, radius * (0.85 + level * 0.55), 0, Math.PI * 2);
|
|
ctx2d.fillStyle = agentLead
|
|
? `rgba(${accent.r},${accent.g},${accent.b},${0.35 + agentRms * 0.5})`
|
|
: `rgba(226,232,240,${0.22 + userRms * 0.5})`;
|
|
ctx2d.fill();
|
|
|
|
const step = Math.max(1, Math.floor(bins.length / barCount));
|
|
const gap = 6;
|
|
const barW = Math.max(4, (Math.min(w, h) * 0.72 - gap * (barCount - 1)) / barCount);
|
|
const totalW = barCount * barW + (barCount - 1) * gap;
|
|
const x0 = cx - totalW / 2;
|
|
const maxBar = Math.min(h, w) * 0.28;
|
|
for (let i = 0; i < barCount; i += 1) {
|
|
const v = (bins[i * step] || 0) / 255;
|
|
const amp = Math.max(idle * 0.25, v) * (0.55 + level);
|
|
const bh = Math.max(8, amp * maxBar);
|
|
const x = x0 + i * (barW + gap);
|
|
const y = cy - bh / 2;
|
|
ctx2d.fillStyle = agentLead
|
|
? `rgba(${accent.r},${accent.g},${accent.b},${0.45 + v * 0.5})`
|
|
: `rgba(203,213,225,${0.4 + v * 0.55})`;
|
|
ctx2d.beginPath();
|
|
if (ctx2d.roundRect) ctx2d.roundRect(x, y, barW, bh, 4);
|
|
else ctx2d.rect(x, y, barW, bh);
|
|
ctx2d.fill();
|
|
}
|
|
};
|
|
draw();
|
|
}
|
|
|
|
function applyStageMode() {
|
|
const root = document.getElementById('eba-root');
|
|
if (!root) return;
|
|
root.classList.toggle('eba-mode-wave', !videoAvatarOn);
|
|
root.classList.toggle('eba-mode-video', videoAvatarOn);
|
|
if (videoAvatarOn) stopWaveLoop();
|
|
else startWaveLoop();
|
|
}
|
|
|
|
function handleIncomingAudio(track, participant, room) {
|
|
console.log('[DEBUG] handleIncomingAudio()', {
|
|
kind: track?.kind,
|
|
participant: participant?.identity,
|
|
isLocal: isLocalParticipant(room, participant)
|
|
});
|
|
if (
|
|
!track ||
|
|
String(track.kind || '').toLowerCase() !== 'audio'
|
|
) {
|
|
return;
|
|
}
|
|
|
|
if (isLocalParticipant(room, participant)) {
|
|
return;
|
|
}
|
|
|
|
// --------------------------------------------
|
|
// Authoritative audio playback
|
|
// --------------------------------------------
|
|
console.log('[DEBUG] Attaching agent audio');
|
|
attachRemoteAudio(track, true);
|
|
|
|
// --------------------------------------------
|
|
// Same audio -> 3D avatar
|
|
// --------------------------------------------
|
|
|
|
const media = mediaTrackFrom(track);
|
|
console.log('[DEBUG] handleIncomingAudio()', {
|
|
kind: track?.kind,
|
|
participant: participant?.identity,
|
|
isLocal: isLocalParticipant(room, participant)
|
|
});
|
|
|
|
lastAgentMediaTrack = media;
|
|
|
|
if (media) {
|
|
hookAvatarAnalyser(media);
|
|
}
|
|
|
|
setTimeout(() => {
|
|
signalAvatarReady(room);
|
|
}, 400);
|
|
}
|
|
|
|
// function ensureSimliConnected(reason) {
|
|
// if (!videoAvatarOn) return;
|
|
// if (!sessionAlive || !livekitRoom || simliRestarting) return;
|
|
// if (!simliIdle && simliClient) return;
|
|
// restartSimliAvatar(reason || 'session-restart');
|
|
// }
|
|
|
|
// async function restartSimliAvatar(reason) {
|
|
// if (!sessionAlive || simliRestarting || !livekitRoom) return;
|
|
// simliRestarting = true;
|
|
// // simliGeneration += 1;
|
|
// setStatus('Reconnecting avatar…');
|
|
// console.warn('[avatar] restarting simli', reason);
|
|
// try {
|
|
// const prev = simliClient;
|
|
// simliClient = null;
|
|
// if (prev && typeof prev.stop === 'function') {
|
|
// await prev.stop().catch(() => {});
|
|
// }
|
|
// const simli = await api(`/public/concierge/${encodeURIComponent(botId)}/simli/token`, {
|
|
// method: 'POST',
|
|
// body: {},
|
|
// });
|
|
// if (!simli?.sessionToken) throw new Error('Avatar session token was empty');
|
|
// const { SimliClient, LogLevel } = await loadSimliClient();
|
|
// const next = makeSimliClient(SimliClient, LogLevel, simli.sessionToken);
|
|
// bindSimliEvents(next);
|
|
// simliClient = next;
|
|
// await next.start();
|
|
// const played = await resumeSimliAudio();
|
|
// pipedTrackId = null;
|
|
// if (played) muteLivekitPlayback();
|
|
// else unmuteLivekitFallback();
|
|
// // simliIdle = false;
|
|
// applyAgentState(readRemoteAgentState(livekitRoom) || agentPipelineState);
|
|
// } catch (err) {
|
|
// console.warn('[avatar] simli restart failed', err);
|
|
// simliIdle = true;
|
|
// setStatus('Avatar disconnected');
|
|
// } finally {
|
|
// simliRestarting = false;
|
|
// }
|
|
// }
|
|
|
|
// function bindSimliEvents(client) {
|
|
// if (!client || typeof client.on !== 'function') return;
|
|
// const gen = simliGeneration;
|
|
// let ready = false;
|
|
// client.on('start', () => {
|
|
// if (gen !== simliGeneration) return;
|
|
// ready = true;
|
|
// // simliIdle = false;
|
|
// muteLivekitPlayback();
|
|
// unmuteSimliPlayback();
|
|
// if (audioEl?.play) audioEl.play().catch(() => {});
|
|
// applyAgentState(readRemoteAgentState(livekitRoom) || agentPipelineState);
|
|
// });
|
|
// client.on('stop', () => {
|
|
// if (gen !== simliGeneration) return;
|
|
// simliIdle = true;
|
|
// setStatus('Idle — speak to continue');
|
|
// });
|
|
// client.on('error', (message) => {
|
|
// if (gen !== simliGeneration) return;
|
|
// console.warn('[avatar] simli error', message);
|
|
// if (sessionAlive && ready) restartSimliAvatar(message || 'error');
|
|
// });
|
|
// }
|
|
|
|
// async function loadSimliClient() {
|
|
// const mod = await import('/embed/simli-client.js');
|
|
// const SimliClient = mod.SimliClient || mod.default?.SimliClient || mod.default;
|
|
// if (typeof SimliClient !== 'function') {
|
|
// throw new Error('SIMLI client failed to load');
|
|
// }
|
|
// return { SimliClient, LogLevel: mod.LogLevel || mod.default?.LogLevel };
|
|
// }
|
|
|
|
// async function resumeSimliAudio() {
|
|
// const ctx = simliClient?.audioContext;
|
|
// if (ctx && ctx.state === 'suspended' && typeof ctx.resume === 'function') {
|
|
// await ctx.resume().catch(() => {});
|
|
// }
|
|
// unmuteSimliPlayback();
|
|
// let played = false;
|
|
// if (audioEl?.play) {
|
|
// played = await audioEl.play().then(() => true).catch(() => false);
|
|
// }
|
|
// if (videoEl?.play) videoEl.play().catch(() => {});
|
|
// return played;
|
|
// }
|
|
|
|
// async function startSimliOverlay() {
|
|
// if (!videoAvatarOn || simliRestarting) return;
|
|
// simliRestarting = true;
|
|
// try {
|
|
// setStatus('Connecting avatar…');
|
|
// const simli = await api(`/public/concierge/${encodeURIComponent(botId)}/simli/token`, {
|
|
// method: 'POST',
|
|
// body: {},
|
|
// });
|
|
// if (!simli?.sessionToken) throw new Error('Avatar session token was empty');
|
|
// const { SimliClient, LogLevel } = await loadSimliClient();
|
|
// const next = makeSimliClient(SimliClient, LogLevel, simli.sessionToken);
|
|
// bindSimliEvents(next);
|
|
// simliClient = next;
|
|
// await next.start();
|
|
// const played = await resumeSimliAudio();
|
|
// pipedTrackId = null;
|
|
// if (played) muteLivekitPlayback();
|
|
// else unmuteLivekitFallback();
|
|
// applyAgentState(readRemoteAgentState(livekitRoom) || agentPipelineState);
|
|
// } catch (err) {
|
|
// console.warn('[avatar] simli overlay failed, voice continues', err);
|
|
// simliClient = null;
|
|
// unmuteLivekitFallback();
|
|
// setStatus('Voice only');
|
|
// } finally {
|
|
// simliRestarting = false;
|
|
// }
|
|
// }
|
|
|
|
async function teardownMedia() {
|
|
sessionAlive = false;
|
|
// simliIdle = false;
|
|
// simliGeneration += 1;
|
|
if (micResumeTimer) {
|
|
clearTimeout(micResumeTimer);
|
|
micResumeTimer = 0;
|
|
}
|
|
// disconnectSimliTts();
|
|
stopWaveLoop();
|
|
userAnalyser = null;
|
|
agentAnalyser = null;
|
|
if (waveAudioCtx) {
|
|
waveAudioCtx.close().catch(() => {});
|
|
waveAudioCtx = null;
|
|
}
|
|
avatarReadySent = false;
|
|
agentPipelineState = '';
|
|
micPublished = false;
|
|
micListening = true;
|
|
lastAgentMediaTrack = null;
|
|
// stopAgentTrackClone();
|
|
// pipedTrackId = null;
|
|
mutedLivekitAudioEls.splice(0).forEach((node) => {
|
|
try {
|
|
if (node.srcObject) node.srcObject = null;
|
|
if (node.parentNode) node.parentNode.removeChild(node);
|
|
} catch {
|
|
/* ignore */
|
|
}
|
|
});
|
|
const room = livekitRoom;
|
|
livekitRoom = null;
|
|
if (room) {
|
|
try {
|
|
await room.disconnect();
|
|
} catch {
|
|
/* ignore */
|
|
}
|
|
}
|
|
// const simli = simliClient;
|
|
// simliClient = null;
|
|
// if (simli && typeof simli.stop === 'function') {
|
|
// try {
|
|
// await simli.stop();
|
|
// } catch {
|
|
// /* ignore */
|
|
// }
|
|
// }
|
|
if (avatarAudioSource) {
|
|
try {
|
|
avatarAudioSource.disconnect();
|
|
} catch {
|
|
// ignore
|
|
}
|
|
|
|
avatarAudioSource = null;
|
|
}
|
|
|
|
avatarAudioAnalyser = null;
|
|
|
|
if (
|
|
window.EBAvatar3D &&
|
|
typeof window.EBAvatar3D.destroy === 'function'
|
|
) {
|
|
window.EBAvatar3D.destroy();
|
|
}
|
|
}
|
|
|
|
async function maybeResume() {
|
|
const params = new URLSearchParams(window.location.search || '');
|
|
const ref = String(params.get('session') || params.get('sessionId') || cfg.sessionId || '').trim();
|
|
if (!ref) return false;
|
|
const data = await api(
|
|
`/public/concierge/${encodeURIComponent(botId)}/session/${encodeURIComponent(ref)}`,
|
|
);
|
|
sessionId = data.sessionId || sessionId;
|
|
messagesEl.innerHTML = '';
|
|
renderChips([]);
|
|
(data.history || []).forEach((m) => {
|
|
addMessage(m.role === 'user' ? 'user' : 'bot', m.text);
|
|
});
|
|
return true;
|
|
}
|
|
|
|
async function loadChat() {
|
|
if (chatReady) return;
|
|
const config = await api(`/public/concierge/${encodeURIComponent(botId)}/config`);
|
|
titleEl.textContent = config.eventName || 'Concierge';
|
|
subEl.textContent = 'Voice and chat';
|
|
if (config.maxMessageLength) inputEl.setAttribute('maxlength', String(config.maxMessageLength));
|
|
if (config.accentColor) {
|
|
document.documentElement.style.setProperty('--eba-accent', String(config.accentColor));
|
|
}
|
|
let resumed = false;
|
|
try {
|
|
resumed = await maybeResume();
|
|
} catch {
|
|
resumed = false;
|
|
}
|
|
if (!resumed && config.greeting) pendingGreeting = String(config.greeting);
|
|
if (!resumed && Array.isArray(config.quickReplies)) pendingQuickReplies = config.quickReplies;
|
|
chatReady = true;
|
|
if (!config.voiceEnabled) {
|
|
throw new Error('Voice is not enabled for this chatbot');
|
|
}
|
|
videoAvatarOn = Boolean(
|
|
config.videoAvatarEnabled ||
|
|
config.avatarEnabled
|
|
);
|
|
|
|
if (videoAvatarOn) {
|
|
if (
|
|
!window.EBAvatar3D ||
|
|
typeof window.EBAvatar3D.init !== 'function'
|
|
) {
|
|
throw new Error(
|
|
'3D avatar client failed to load'
|
|
);
|
|
}
|
|
|
|
await window.EBAvatar3D.init({
|
|
container: avatarStageEl,
|
|
modelUrl: '/embed/avatar/model.glb',
|
|
});
|
|
|
|
console.info(
|
|
'[avatar3d] avatar initialized'
|
|
);
|
|
}
|
|
}
|
|
|
|
async function startSession() {
|
|
console.log('[DEBUG] startSession() START');
|
|
if (started) return;
|
|
started = true;
|
|
hideStartOverlay();
|
|
setError('');
|
|
setStatus('Connecting…');
|
|
|
|
if (!botId || !apiBase) {
|
|
throw new Error('Missing botId or apiBase');
|
|
}
|
|
if (!Livekit || !Livekit.Room) {
|
|
throw new Error('Voice client failed to load');
|
|
}
|
|
|
|
await loadChat();
|
|
console.log('[DEBUG] loadChat() DONE', {
|
|
videoAvatarOn,
|
|
avatarStageEl: !!avatarStageEl,
|
|
EBAvatar3D: !!window.EBAvatar3D
|
|
});
|
|
|
|
if (!navigator.mediaDevices?.getUserMedia) {
|
|
throw new Error('This browser cannot access the microphone');
|
|
}
|
|
const preview = await navigator.mediaDevices.getUserMedia({ audio: true });
|
|
preview.getTracks().forEach((t) => t.stop());
|
|
|
|
const granted = await api(`/public/concierge/${encodeURIComponent(botId)}/voice/token`, {
|
|
method: 'POST',
|
|
body: { sessionId: sessionId || undefined },
|
|
});
|
|
sessionId = granted.sessionId || sessionId;
|
|
|
|
sessionAlive = true;
|
|
// if (!videoAvatarOn) startWaveLoop();
|
|
|
|
const room = new Livekit.Room({
|
|
adaptiveStream: false,
|
|
dynacast: false,
|
|
audioCaptureDefaults: {
|
|
echoCancellation: true,
|
|
noiseSuppression: true,
|
|
autoGainControl: true,
|
|
},
|
|
});
|
|
livekitRoom = room;
|
|
|
|
room.on(Livekit.RoomEvent.Disconnected, () => {
|
|
if (livekitRoom === room) {
|
|
livekitRoom = null;
|
|
sessionAlive = false;
|
|
setStatus('Disconnected');
|
|
}
|
|
});
|
|
room.on(Livekit.RoomEvent.TrackSubscribed, (track, pub, participant) => {
|
|
console.log('[DEBUG] TrackSubscribed', {
|
|
kind: track?.kind,
|
|
source: pub?.source,
|
|
participant: participant?.identity,
|
|
trackSid: pub?.trackSid
|
|
});
|
|
handleIncomingAudio(track, participant, room);
|
|
});
|
|
if (Livekit.RoomEvent.LocalTrackPublished) {
|
|
room.on(Livekit.RoomEvent.LocalTrackPublished, (pub) => {
|
|
const media = mediaTrackFrom(pub?.track);
|
|
if (media) hookWaveAnalyser(media, 'user');
|
|
});
|
|
}
|
|
if (Livekit.RoomEvent.DataReceived) {
|
|
room.on(Livekit.RoomEvent.DataReceived, (payload, participant) => {
|
|
if (isLocalParticipant(room, participant)) return;
|
|
const state = parseAgentStatePayload(payload);
|
|
if (state) applyAgentState(state);
|
|
});
|
|
}
|
|
if (Livekit.RoomEvent.ParticipantAttributesChanged) {
|
|
room.on(Livekit.RoomEvent.ParticipantAttributesChanged, (_changed, participant) => {
|
|
if (isLocalParticipant(room, participant)) return;
|
|
const state = participant?.attributes?.[AGENT_STATE_ATTR];
|
|
if (state) applyAgentState(state);
|
|
});
|
|
}
|
|
room.on(Livekit.RoomEvent.TranscriptionReceived, (segments, participant) => {
|
|
const local = isLocalParticipant(room, participant);
|
|
(segments || []).forEach((seg) => {
|
|
if (!seg || !seg.final) return;
|
|
if (agentPipelineState === 'speaking' && local) {
|
|
return;
|
|
}
|
|
if (rememberTranscript(seg.id || `${local ? 'user' : 'bot'}:${seg.text}`)) return;
|
|
if (!local && pendingGreeting && normalizeSpeech(seg.text) === normalizeSpeech(pendingGreeting)) {
|
|
showPendingGreeting();
|
|
return;
|
|
}
|
|
addMessage(local ? 'user' : 'bot', seg.text);
|
|
});
|
|
});
|
|
room.on(Livekit.RoomEvent.ActiveSpeakersChanged, (speakers) => {
|
|
if (videoAvatarOn) return;
|
|
|
|
const localId = room.localParticipant?.identity;
|
|
|
|
const agentSpeaking = (speakers || []).some(
|
|
(p) => p?.identity && p.identity !== localId
|
|
);
|
|
|
|
setStatus(agentSpeaking ? 'Speaking' : 'Listening');
|
|
});
|
|
|
|
room.on(Livekit.RoomEvent.ParticipantConnected, (participant) => {
|
|
console.log('[DEBUG] ParticipantConnected', {
|
|
identity: participant?.identity,
|
|
sid: participant?.sid,
|
|
});
|
|
|
|
participant.trackPublications.forEach((pub) => {
|
|
console.log('[DEBUG] Remote publication', {
|
|
kind: pub?.kind,
|
|
source: pub?.source,
|
|
trackSid: pub?.trackSid,
|
|
subscribed: pub?.isSubscribed,
|
|
hasTrack: !!pub?.track,
|
|
});
|
|
|
|
if (pub?.track) {
|
|
handleIncomingAudio(pub.track, participant, room);
|
|
}
|
|
});
|
|
});
|
|
|
|
|
|
room.on(Livekit.RoomEvent.ParticipantConnected, (participant) => {
|
|
console.log('[DEBUG] ParticipantConnected', {
|
|
identity: participant?.identity,
|
|
sid: participant?.sid,
|
|
});
|
|
});
|
|
|
|
room.on(Livekit.RoomEvent.ParticipantDisconnected, (participant) => {
|
|
console.log('[DEBUG] ParticipantDisconnected', {
|
|
identity: participant?.identity,
|
|
sid: participant?.sid,
|
|
});
|
|
});
|
|
|
|
room.on(Livekit.RoomEvent.LocalTrackPublished, (publication) => {
|
|
console.log('[DEBUG] LocalTrackPublished', {
|
|
kind: publication?.kind,
|
|
source: publication?.source,
|
|
trackSid: publication?.trackSid,
|
|
});
|
|
});
|
|
|
|
|
|
await room.connect(granted.url, granted.token);
|
|
console.log('[DEBUG] LiveKit CONNECTED', {
|
|
localParticipant: room.localParticipant?.identity,
|
|
remoteParticipants: room.remoteParticipants?.size
|
|
});
|
|
if (typeof room.startAudio === 'function') {
|
|
await room.startAudio().catch(() => {});
|
|
}
|
|
room.remoteParticipants.forEach((participant) => {
|
|
participant.trackPublications.forEach((pub) => {
|
|
if (pub?.track) handleIncomingAudio(pub.track, participant, room);
|
|
});
|
|
});
|
|
|
|
let micPub = null;
|
|
if (typeof room.localParticipant.setMicrophoneEnabled === 'function') {
|
|
micPub = await room.localParticipant.setMicrophoneEnabled(true);
|
|
}
|
|
if (!micPub && typeof Livekit.createLocalAudioTrack === 'function') {
|
|
const micTrack = await Livekit.createLocalAudioTrack({
|
|
echoCancellation: true,
|
|
noiseSuppression: true,
|
|
autoGainControl: true,
|
|
});
|
|
micPub = await room.localParticipant.publishTrack(micTrack);
|
|
}
|
|
if (!micPub) throw new Error('Microphone did not publish. Allow mic access and try again.');
|
|
micPublished = true;
|
|
console.log('[DEBUG] MIC PUBLISHED', {
|
|
trackSid: micPub?.trackSid,
|
|
kind: micPub?.kind,
|
|
source: micPub?.source,
|
|
});
|
|
micListening = true;
|
|
const localMedia = mediaTrackFrom(micPub.track);
|
|
if (localMedia) hookWaveAnalyser(localMedia, 'user');
|
|
room.remoteParticipants.forEach((participant) => {
|
|
const state = participant?.attributes?.[AGENT_STATE_ATTR];
|
|
if (state && !isLocalParticipant(room, participant)) applyAgentState(state);
|
|
});
|
|
if (!videoAvatarOn) {
|
|
const ctx = ensureWaveAudioCtx();
|
|
if (ctx && ctx.state === 'suspended') await ctx.resume().catch(() => {});
|
|
setTimeout(() => signalAvatarReady(room), 400);
|
|
setStatus('Listening');
|
|
return;
|
|
}
|
|
// setStatus('Connecting avatar…');
|
|
// try {
|
|
// await Promise.race([
|
|
// startSimliOverlay(),
|
|
// new Promise((resolve) => setTimeout(resolve, 2500)),
|
|
// ]);
|
|
// } catch (err) {
|
|
// console.warn('[avatar] simli overlay', err);
|
|
// }
|
|
// await signalAvatarReady(room);
|
|
// applyAgentState(readRemoteAgentState(room) || agentPipelineState);
|
|
setStatus('Listening');
|
|
|
|
await signalAvatarReady(room);
|
|
|
|
applyAgentState(
|
|
readRemoteAgentState(room) ||
|
|
agentPipelineState
|
|
);
|
|
}
|
|
|
|
function needsGesture(err) {
|
|
const msg = String(err?.name || err?.message || err || '').toLowerCase();
|
|
return /notallowed|permission|denied|gesture|autoplay|aborterror|notallowederror|securityerror/.test(
|
|
msg,
|
|
);
|
|
}
|
|
|
|
async function boot() {
|
|
try {
|
|
await startSession();
|
|
} catch (err) {
|
|
started = false;
|
|
console.warn('[avatar] start failed', err);
|
|
await teardownMedia();
|
|
const message = err.message || 'Could not start';
|
|
setError(message);
|
|
setStatus('Waiting');
|
|
showStartOverlay(needsGesture(err) ? 'Tap to start' : 'Tap to retry', message);
|
|
}
|
|
}
|
|
|
|
formEl.addEventListener('submit', (e) => {
|
|
e.preventDefault();
|
|
sendMessage();
|
|
});
|
|
|
|
startBtn.addEventListener('click', () => {
|
|
hideStartOverlay();
|
|
boot();
|
|
});
|
|
|
|
if (!botId || !apiBase) {
|
|
setError('Missing window.EB_CONCIERGE.botId or apiBase');
|
|
setStatus('Not configured');
|
|
showStartOverlay('Not configured', 'Set botId and apiBase on this page.');
|
|
} else {
|
|
boot();
|
|
}
|