@hivegpt/hiveai-angular 0.0.584 → 0.0.586

package/fesm2015/hivegpt-hiveai-angular.js

@@ -5,16 +5,15 @@ import { HttpClient, HttpHeaders } from '@angular/common/http';
 import * as i0 from '@angular/core';
 import { Injectable, InjectionToken, Inject, PLATFORM_ID, Optional, NgZone, EventEmitter, Component, Injector, Output, Input, ElementRef, ChangeDetectionStrategy, ChangeDetectorRef, Renderer2, ViewContainerRef, ViewChild, ViewChildren, NgModule, Pipe } from '@angular/core';
 import { DomSanitizer } from '@angular/platform-browser';
-import { BehaviorSubject, of, throwError, Subject, Subscription } from 'rxjs';
-import { switchMap, catchError, filter, take, map, tap } from 'rxjs/operators';
+import { BehaviorSubject, of, throwError, Subject, Subscription, combineLatest } from 'rxjs';
+import { switchMap, catchError, filter, take, map, takeUntil, tap } from 'rxjs/operators';
 import { isPlatformBrowser, CommonModule, DOCUMENT } from '@angular/common';
 import { Socket } from 'ngx-socket-io';
 import { Validators, FormBuilder, FormsModule, ReactiveFormsModule } from '@angular/forms';
 import * as SpeechSDK from 'microsoft-cognitiveservices-speech-sdk';
 import * as marked from 'marked';
 import { __awaiter } from 'tslib';
-import { PipecatClient, RTVIEvent } from '@pipecat-ai/client-js';
-import { WebSocketTransport } from '@pipecat-ai/websocket-transport';
+import Daily from '@daily-co/daily-js';
 import { MatIconModule } from '@angular/material/icon';
 import { MatSidenavModule } from '@angular/material/sidenav';
 import { QuillModule } from 'ngx-quill';
@@ -685,8 +684,8 @@ BotsService.ctorParameters = () => [
 ];
 
 /**
- * Audio analyzer for waveform visualization and local (mic) speaking detection.
- * VoiceAgentService may combine this with WebSocket server events for call state.
+ * Audio analyzer for waveform visualization only.
+ * Do NOT use isUserSpeaking$ for call state; speaking state must come from Daily.js.
  */
 class AudioAnalyzerService {
     constructor() {
@@ -807,23 +806,423 @@ AudioAnalyzerService.decorators = [
 ];
 
 /**
- * Voice agent orchestrator using the official PipecatClient SDK.
+ * WebSocket-only client for voice agent signaling.
+ * CRITICAL: Uses native WebSocket only. NO Socket.IO, NO ngx-socket-io.
  *
- * Audio flow (mirrors the React reference implementation):
- *  - Local mic: acquired by PipecatClient.initDevices(); local track fed to
- *    AudioAnalyzerService for waveform visualisation.
- *  - Bot audio: received as a MediaStreamTrack via RTVIEvent.TrackStarted,
- *    played through a hidden <audio> element.
- *  - All binary protobuf framing / RTVI protocol handled by
- *    @pipecat-ai/client-js + @pipecat-ai/websocket-transport.
+ * Responsibilities:
+ * - Connect to ws_url (from POST /ai/ask-voice response)
+ * - Parse JSON messages (room_created, user_transcript, bot_transcript)
+ * - Emit roomCreated$, userTranscript$, botTranscript$
+ * - NO audio logic, NO mic logic. Audio is handled by Daily.js (WebRTC).
+ */
+class WebSocketVoiceClientService {
+    constructor() {
+        this.ws = null;
+        this.roomCreatedSubject = new Subject();
+        this.userTranscriptSubject = new Subject();
+        this.botTranscriptSubject = new Subject();
+        /** Emits room_url when backend sends room_created. */
+        this.roomCreated$ = this.roomCreatedSubject.asObservable();
+        /** Emits user transcript updates. */
+        this.userTranscript$ = this.userTranscriptSubject.asObservable();
+        /** Emits bot transcript updates. */
+        this.botTranscript$ = this.botTranscriptSubject.asObservable();
+    }
+    /** Connect to signaling WebSocket. No audio over this connection. */
+    connect(wsUrl) {
+        var _a;
+        if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
+            return;
+        }
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        try {
+            this.ws = new WebSocket(wsUrl);
+            this.ws.onmessage = (event) => {
+                var _a;
+                try {
+                    const msg = JSON.parse(event.data);
+                    if ((msg === null || msg === void 0 ? void 0 : msg.type) === 'room_created') {
+                        const roomUrl = ((_a = msg.room_url) !== null && _a !== void 0 ? _a : msg.roomUrl);
+                        if (typeof roomUrl === 'string') {
+                            this.roomCreatedSubject.next(roomUrl);
+                        }
+                    }
+                    else if ((msg === null || msg === void 0 ? void 0 : msg.type) === 'user_transcript' && typeof msg.text === 'string') {
+                        this.userTranscriptSubject.next({
+                            text: msg.text,
+                            final: msg.final === true,
+                        });
+                    }
+                    else if ((msg === null || msg === void 0 ? void 0 : msg.type) === 'bot_transcript' && typeof msg.text === 'string') {
+                        this.botTranscriptSubject.next(msg.text);
+                    }
+                }
+                catch (_b) {
+                    // Ignore non-JSON or unknown messages
+                }
+            };
+            this.ws.onerror = () => {
+                this.disconnect();
+            };
+            this.ws.onclose = () => {
+                this.ws = null;
+            };
+        }
+        catch (err) {
+            console.error('WebSocketVoiceClient: connect failed', err);
+            this.ws = null;
+            throw err;
+        }
+    }
+    /** Disconnect and cleanup. */
+    disconnect() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+    /** Whether the WebSocket is open. */
+    get isConnected() {
+        var _a;
+        return ((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN;
+    }
+}
+WebSocketVoiceClientService.ɵprov = i0.ɵɵdefineInjectable({ factory: function WebSocketVoiceClientService_Factory() { return new WebSocketVoiceClientService(); }, token: WebSocketVoiceClientService, providedIn: "root" });
+WebSocketVoiceClientService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+
+/**
+ * Daily.js WebRTC client for voice agent audio.
+ * Responsibilities:
+ * - Create and manage Daily CallObject
+ * - Join Daily room using room_url
+ * - Handle mic capture + speaker playback
+ * - Bot speaking detection via AnalyserNode on remote track (instant)
+ * - User speaking detection via active-speaker-change
+ * - Expose speaking$ (bot speaking), userSpeaking$ (user speaking), micMuted$
+ * - Expose localStream$ for waveform visualization (AudioAnalyzerService)
+ */
+class DailyVoiceClientService {
+    constructor(ngZone) {
+        this.ngZone = ngZone;
+        this.callObject = null;
+        this.localStream = null;
+        this.localSessionId = null;
+        /** Explicit playback of remote (bot) audio; required in some browsers. */
+        this.remoteAudioElement = null;
+        /** AnalyserNode-based remote audio monitor for instant bot speaking detection. */
+        this.remoteAudioContext = null;
+        this.remoteSpeakingRAF = null;
+        this.speakingSubject = new BehaviorSubject(false);
+        this.userSpeakingSubject = new BehaviorSubject(false);
+        this.micMutedSubject = new BehaviorSubject(false);
+        this.localStreamSubject = new BehaviorSubject(null);
+        this.firstRemoteAudioFrameSubject = new BehaviorSubject(false);
+        /** True when bot (remote participant) is the active speaker. */
+        this.speaking$ = this.speakingSubject.asObservable();
+        /** True when user (local participant) is the active speaker. */
+        this.userSpeaking$ = this.userSpeakingSubject.asObservable();
+        /** True when mic is muted. */
+        this.micMuted$ = this.micMutedSubject.asObservable();
+        /** Emits local mic stream for waveform visualization. */
+        this.localStream$ = this.localStreamSubject.asObservable();
+        /** Emits true once when first remote audio frame starts playing. */
+        this.firstRemoteAudioFrame$ = this.firstRemoteAudioFrameSubject.asObservable();
+    }
+    /**
+     * Connect to Daily room. Acquires mic first for waveform, then joins with audio.
+     * @param roomUrl Daily room URL (from room_created)
+     * @param token Optional meeting token
+     */
+    connect(roomUrl, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.callObject) {
+                yield this.disconnect();
+            }
+            try {
+                // Get mic stream for both Daily and waveform (single capture)
+                const stream = yield navigator.mediaDevices.getUserMedia({ audio: true });
+                const audioTrack = stream.getAudioTracks()[0];
+                if (!audioTrack) {
+                    stream.getTracks().forEach((t) => t.stop());
+                    throw new Error('No audio track');
+                }
+                this.localStream = stream;
+                this.localStreamSubject.next(stream);
+                // Create audio-only call object
+                // videoSource: false = no camera, audioSource = our mic track
+                const callObject = Daily.createCallObject({
+                    videoSource: false,
+                    audioSource: audioTrack,
+                });
+                this.callObject = callObject;
+                this.setupEventHandlers(callObject);
+                // Join room; Daily handles playback of remote (bot) audio automatically.
+                // Only pass token when it's a non-empty string (Daily rejects undefined/non-string).
+                const joinOptions = { url: roomUrl };
+                if (typeof token === 'string' && token.trim() !== '') {
+                    joinOptions.token = token;
+                }
+                yield callObject.join(joinOptions);
+                console.log(`[VoiceDebug] Room connected (Daily join complete) — ${new Date().toISOString()}`);
+                const participants = callObject.participants();
+                if (participants === null || participants === void 0 ? void 0 : participants.local) {
+                    this.localSessionId = participants.local.session_id;
+                }
+                // Start with mic muted; VoiceAgentService auto-unmutes after first remote audio frame.
+                callObject.setLocalAudio(false);
+                this.micMutedSubject.next(true);
+            }
+            catch (err) {
+                this.cleanup();
+                throw err;
+            }
+        });
+    }
+    setupEventHandlers(call) {
+        // active-speaker-change: used ONLY for user speaking detection.
+        // Bot speaking is detected by our own AnalyserNode (instant, no debounce).
+        call.on('active-speaker-change', (event) => {
+            this.ngZone.run(() => {
+                var _a;
+                const peerId = (_a = event === null || event === void 0 ? void 0 : event.activeSpeaker) === null || _a === void 0 ? void 0 : _a.peerId;
+                if (!peerId || !this.localSessionId) {
+                    this.userSpeakingSubject.next(false);
+                    return;
+                }
+                const isLocal = peerId === this.localSessionId;
+                this.userSpeakingSubject.next(isLocal);
+            });
+        });
+        // track-started / track-stopped: set up remote audio playback + AnalyserNode monitor.
+        call.on('track-started', (event) => {
+            this.ngZone.run(() => {
+                var _a, _b, _c, _d;
+                const p = event === null || event === void 0 ? void 0 : event.participant;
+                const type = (_a = event === null || event === void 0 ? void 0 : event.type) !== null && _a !== void 0 ? _a : (_b = event === null || event === void 0 ? void 0 : event.track) === null || _b === void 0 ? void 0 : _b.kind;
+                const track = event === null || event === void 0 ? void 0 : event.track;
+                if (p && !p.local && type === 'audio') {
+                    console.log(`[VoiceDebug] Got audio track from backend (track-started) — readyState=${track === null || track === void 0 ? void 0 : track.readyState}, muted=${track === null || track === void 0 ? void 0 : track.muted} — ${new Date().toISOString()}`);
+                    const audioTrack = track !== null && track !== void 0 ? track : (_d = (_c = p.tracks) === null || _c === void 0 ? void 0 : _c.audio) === null || _d === void 0 ? void 0 : _d.track;
+                    if (audioTrack && typeof audioTrack === 'object') {
+                        this.playRemoteTrack(audioTrack);
+                        this.monitorRemoteAudio(audioTrack);
+                    }
+                }
+            });
+        });
+        call.on('track-stopped', (event) => {
+            this.ngZone.run(() => {
+                var _a, _b;
+                const p = event === null || event === void 0 ? void 0 : event.participant;
+                const type = (_a = event === null || event === void 0 ? void 0 : event.type) !== null && _a !== void 0 ? _a : (_b = event === null || event === void 0 ? void 0 : event.track) === null || _b === void 0 ? void 0 : _b.kind;
+                if (p && !p.local && type === 'audio') {
+                    this.stopRemoteAudioMonitor();
+                    this.stopRemoteAudio();
+                }
+            });
+        });
+        call.on('left-meeting', () => {
+            this.ngZone.run(() => this.cleanup());
+        });
+        call.on('error', (event) => {
+            this.ngZone.run(() => {
+                var _a;
+                console.error('DailyVoiceClient: Daily error', (_a = event === null || event === void 0 ? void 0 : event.errorMsg) !== null && _a !== void 0 ? _a : event);
+                this.cleanup();
+            });
+        });
+    }
+    /**
+     * Play remote (bot) audio track via a dedicated audio element.
+     * Required in many browsers where Daily's internal playback does not output to speakers.
+     */
+    playRemoteTrack(track) {
+        this.stopRemoteAudio();
+        try {
+            console.log(`[VoiceDebug] playRemoteTrack called — track.readyState=${track.readyState}, track.muted=${track.muted} — ${new Date().toISOString()}`);
+            track.onunmute = () => {
+                console.log(`[VoiceDebug] Remote audio track UNMUTED (audio data arriving) — ${new Date().toISOString()}`);
+            };
+            const stream = new MediaStream([track]);
+            const audio = new Audio();
+            audio.autoplay = true;
+            audio.srcObject = stream;
+            this.remoteAudioElement = audio;
+            audio.onplaying = () => {
+                console.log(`[VoiceDebug] Audio element PLAYING (browser started playback) — ${new Date().toISOString()}`);
+            };
+            let firstTimeUpdate = true;
+            audio.ontimeupdate = () => {
+                if (firstTimeUpdate) {
+                    firstTimeUpdate = false;
+                    console.log(`[VoiceDebug] Audio element first TIMEUPDATE (actual audio output) — ${new Date().toISOString()}`);
+                    this.firstRemoteAudioFrameSubject.next(true);
+                }
+            };
+            const p = audio.play();
+            if (p && typeof p.then === 'function') {
+                p.then(() => {
+                    console.log(`[VoiceDebug] audio.play() resolved — ${new Date().toISOString()}`);
+                    this.firstRemoteAudioFrameSubject.next(true);
+                }).catch((err) => {
+                    console.warn('DailyVoiceClient: remote audio play failed (may need user gesture)', err);
+                });
+            }
+        }
+        catch (err) {
+            console.warn('DailyVoiceClient: failed to create remote audio element', err);
+        }
+    }
+    /**
+     * Monitor remote audio track energy via AnalyserNode.
+     * Polls at ~60fps and flips speakingSubject based on actual audio energy.
+     */
+    monitorRemoteAudio(track) {
+        this.stopRemoteAudioMonitor();
+        try {
+            const ctx = new AudioContext();
+            const source = ctx.createMediaStreamSource(new MediaStream([track]));
+            const analyser = ctx.createAnalyser();
+            analyser.fftSize = 256;
+            source.connect(analyser);
+            this.remoteAudioContext = ctx;
+            const dataArray = new Uint8Array(analyser.frequencyBinCount);
+            const THRESHOLD = 5;
+            const SILENCE_MS = 1500;
+            let lastSoundTime = 0;
+            let isSpeaking = false;
+            const poll = () => {
+                if (!this.remoteAudioContext)
+                    return;
+                analyser.getByteFrequencyData(dataArray);
+                let sum = 0;
+                for (let i = 0; i < dataArray.length; i++) {
+                    sum += dataArray[i];
+                }
+                const avg = sum / dataArray.length;
+                const now = Date.now();
+                if (avg > THRESHOLD) {
+                    lastSoundTime = now;
+                    if (!isSpeaking) {
+                        isSpeaking = true;
+                        console.log(`[VoiceDebug] Bot audio energy detected (speaking=true) — avg=${avg.toFixed(1)} — ${new Date().toISOString()}`);
+                        this.ngZone.run(() => {
+                            this.userSpeakingSubject.next(false);
+                            this.speakingSubject.next(true);
+                        });
+                    }
+                }
+                else if (isSpeaking && now - lastSoundTime > SILENCE_MS) {
+                    isSpeaking = false;
+                    console.log(`[VoiceDebug] Bot audio silence detected (speaking=false) — ${new Date().toISOString()}`);
+                    this.ngZone.run(() => this.speakingSubject.next(false));
+                }
+                this.remoteSpeakingRAF = requestAnimationFrame(poll);
+            };
+            this.remoteSpeakingRAF = requestAnimationFrame(poll);
+        }
+        catch (err) {
+            console.warn('DailyVoiceClient: failed to create remote audio monitor', err);
+        }
+    }
+    stopRemoteAudioMonitor() {
+        if (this.remoteSpeakingRAF) {
+            cancelAnimationFrame(this.remoteSpeakingRAF);
+            this.remoteSpeakingRAF = null;
+        }
+        if (this.remoteAudioContext) {
+            this.remoteAudioContext.close().catch(() => { });
+            this.remoteAudioContext = null;
+        }
+    }
+    stopRemoteAudio() {
+        if (this.remoteAudioElement) {
+            try {
+                this.remoteAudioElement.pause();
+                this.remoteAudioElement.srcObject = null;
+            }
+            catch (_) { }
+            this.remoteAudioElement = null;
+        }
+    }
+    /** Set mic muted state. */
+    setMuted(muted) {
+        if (!this.callObject)
+            return;
+        this.callObject.setLocalAudio(!muted);
+        this.micMutedSubject.next(muted);
+    }
+    /** Disconnect and cleanup. */
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.callObject) {
+                this.cleanup();
+                return;
+            }
+            try {
+                yield this.callObject.leave();
+            }
+            catch (e) {
+                // ignore
+            }
+            this.cleanup();
+        });
+    }
+    cleanup() {
+        this.stopRemoteAudioMonitor();
+        this.stopRemoteAudio();
+        if (this.callObject) {
+            this.callObject.destroy().catch(() => { });
+            this.callObject = null;
+        }
+        if (this.localStream) {
+            this.localStream.getTracks().forEach((t) => t.stop());
+            this.localStream = null;
+        }
+        this.localSessionId = null;
+        this.speakingSubject.next(false);
+        this.userSpeakingSubject.next(false);
+        this.localStreamSubject.next(null);
+        this.firstRemoteAudioFrameSubject.next(false);
+        // Keep last micMuted state; will reset on next connect
+    }
+}
+DailyVoiceClientService.ɵprov = i0.ɵɵdefineInjectable({ factory: function DailyVoiceClientService_Factory() { return new DailyVoiceClientService(i0.ɵɵinject(i0.NgZone)); }, token: DailyVoiceClientService, providedIn: "root" });
+DailyVoiceClientService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+DailyVoiceClientService.ctorParameters = () => [
+    { type: NgZone }
+];
+
+/**
+ * Voice agent orchestrator. Coordinates WebSocket (signaling) and Daily.js (WebRTC audio).
+ *
+ * CRITICAL: This service must NEVER use Socket.IO or ngx-socket-io. Voice flow uses only:
+ * - Native WebSocket (WebSocketVoiceClientService) for signaling (room_created, transcripts)
+ * - Daily.js (DailyVoiceClientService) for WebRTC audio. Audio does NOT flow over WebSocket.
+ *
+ * - Maintains callState, statusText, duration, isMicMuted, isUserSpeaking, audioLevels
+ * - Uses WebSocket for room_created and transcripts only (no audio)
+ * - Uses Daily.js for all audio, mic, and real-time speaking detection
  */
 class VoiceAgentService {
-    constructor(audioAnalyzer, platformTokenRefresh, ngZone, 
+    constructor(audioAnalyzer, wsClient, dailyClient, platformTokenRefresh, 
     /** `Object` not `object` — ngc metadata collection rejects the `object` type in DI params. */
     platformId) {
         this.audioAnalyzer = audioAnalyzer;
+        this.wsClient = wsClient;
+        this.dailyClient = dailyClient;
         this.platformTokenRefresh = platformTokenRefresh;
-        this.ngZone = ngZone;
         this.platformId = platformId;
         this.callStateSubject = new BehaviorSubject('idle');
         this.statusTextSubject = new BehaviorSubject('');
@@ -835,10 +1234,9 @@ class VoiceAgentService {
         this.botTranscriptSubject = new Subject();
         this.callStartTime = 0;
         this.durationInterval = null;
-        this.pcClient = null;
-        this.botAudioElement = null;
         this.subscriptions = new Subscription();
         this.destroy$ = new Subject();
+        this.hasAutoUnmutedAfterFirstAudio = false;
         this.callState$ = this.callStateSubject.asObservable();
         this.statusText$ = this.statusTextSubject.asObservable();
         this.duration$ = this.durationSubject.asObservable();
@@ -847,228 +1245,199 @@ class VoiceAgentService {
         this.audioLevels$ = this.audioLevelsSubject.asObservable();
         this.userTranscript$ = this.userTranscriptSubject.asObservable();
         this.botTranscript$ = this.botTranscriptSubject.asObservable();
+        // Waveform visualization only - do NOT use for speaking state
         this.subscriptions.add(this.audioAnalyzer.audioLevels$.subscribe((levels) => this.audioLevelsSubject.next(levels)));
     }
     ngOnDestroy() {
         this.destroy$.next();
         this.subscriptions.unsubscribe();
-        void this.disconnect();
+        this.disconnect();
     }
-    /** Reset to idle (e.g. when modal re-opens so user can click Start Call). */
+    /** Reset to idle state (e.g. when modal opens so user can click Start Call). */
     resetToIdle() {
         if (this.callStateSubject.value === 'idle')
             return;
-        void this.disconnect();
+        this.stopDurationTimer();
+        this.audioAnalyzer.stop();
+        this.wsClient.disconnect();
+        // Fire-and-forget: Daily disconnect is async; connect() will await if needed
+        void this.dailyClient.disconnect();
         this.callStateSubject.next('idle');
         this.statusTextSubject.next('');
         this.durationSubject.next('0:00');
+        this.hasAutoUnmutedAfterFirstAudio = false;
     }
     connect(apiUrl, token, botId, conversationId, apiKey, eventToken, eventId, eventUrl, domainAuthority, usersApiUrl) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.callStateSubject.value !== 'idle') {
-                console.warn('[HiveGpt Voice] Call already in progress');
+                console.warn('Call already in progress');
                 return;
             }
             try {
                 this.callStateSubject.next('connecting');
                 this.statusTextSubject.next('Connecting...');
                 let accessToken = token;
+                // Align with chat drawer token handling: always delegate to
+                // PlatformTokenRefreshService when we have a usersApiUrl, so it can
+                // fall back to stored tokens even if the caller passed an empty token.
                 if (usersApiUrl && isPlatformBrowser(this.platformId)) {
                     try {
                         const ensured = yield this.platformTokenRefresh
                             .ensureValidAccessToken(token, usersApiUrl)
                             .pipe(take(1))
                             .toPromise();
-                        if (ensured === null || ensured === void 0 ? void 0 : ensured.accessToken)
+                        if (ensured === null || ensured === void 0 ? void 0 : ensured.accessToken) {
                             accessToken = ensured.accessToken;
+                        }
                     }
                     catch (e) {
-                        console.warn('[HiveGpt Voice] Token refresh failed', e);
+                        console.warn('[HiveGpt Voice] Token refresh before connect failed', e);
                     }
                 }
                 const baseUrl = apiUrl.replace(/\/$/, '');
-                const pcClient = new PipecatClient({
-                    transport: new WebSocketTransport(),
-                    enableMic: true,
-                    enableCam: false,
-                    callbacks: {
-                        onConnected: () => this.ngZone.run(() => this.onPipecatConnected()),
-                        onDisconnected: () => this.ngZone.run(() => this.onPipecatDisconnected()),
-                        onBotReady: () => this.ngZone.run(() => this.onBotReady()),
-                        onUserTranscript: (data) => this.ngZone.run(() => this.userTranscriptSubject.next({ text: data.text, final: !!data.final })),
-                        onBotTranscript: (data) => this.ngZone.run(() => this.botTranscriptSubject.next(data.text)),
-                        onError: (err) => {
-                            this.ngZone.run(() => {
-                                console.error('[HiveGpt Voice] PipecatClient error', err);
-                                this.callStateSubject.next('ended');
-                                this.statusTextSubject.next('Connection failed');
-                            });
-                        },
-                    },
-                });
-                this.pcClient = pcClient;
-                // Bot audio arrives as a MediaStreamTrack — wire to a hidden <audio> element
-                pcClient.on(RTVIEvent.TrackStarted, (track, participant) => {
-                    if (!(participant === null || participant === void 0 ? void 0 : participant.local) && track.kind === 'audio') {
-                        this.ngZone.run(() => this.setupBotAudioTrack(track));
-                    }
-                });
-                // Speaking state comes straight from RTVI events
-                pcClient.on(RTVIEvent.BotStartedSpeaking, () => this.ngZone.run(() => this.onBotStartedSpeaking()));
-                pcClient.on(RTVIEvent.BotStoppedSpeaking, () => this.ngZone.run(() => this.onBotStoppedSpeaking()));
-                pcClient.on(RTVIEvent.UserStartedSpeaking, () => this.ngZone.run(() => {
-                    this.isUserSpeakingSubject.next(true);
-                    this.callStateSubject.next('listening');
-                }));
-                pcClient.on(RTVIEvent.UserStoppedSpeaking, () => this.ngZone.run(() => {
-                    this.isUserSpeakingSubject.next(false);
-                    if (this.callStateSubject.value === 'listening') {
-                        this.callStateSubject.next('connected');
-                    }
-                }));
-                // Acquire mic (triggers browser permission prompt)
-                yield pcClient.initDevices();
-                // Build headers using the browser Headers API (required by pipecat's APIRequest type)
-                const requestHeaders = new Headers();
-                requestHeaders.append('Authorization', `Bearer ${accessToken}`);
-                requestHeaders.append('x-api-key', apiKey);
-                requestHeaders.append('hive-bot-id', botId);
-                requestHeaders.append('domain-authority', domainAuthority);
-                requestHeaders.append('eventUrl', eventUrl);
-                requestHeaders.append('eventId', eventId);
-                requestHeaders.append('eventToken', eventToken);
-                requestHeaders.append('ngrok-skip-browser-warning', 'true');
-                // POST to /ai/ask-voice-socket → receives { ws_url } → WebSocketTransport connects
-                yield pcClient.startBotAndConnect({
-                    endpoint: `${baseUrl}/ai/ask-voice-socket`,
-                    headers: requestHeaders,
-                    requestData: {
+                const postUrl = `${baseUrl}/ai/ask-voice`;
+                const headers = {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${accessToken}`,
+                    'x-api-key': apiKey,
+                    'hive-bot-id': botId,
+                    'domain-authority': domainAuthority,
+                    eventUrl,
+                    eventId,
+                    eventToken,
+                    'ngrok-skip-browser-warning': 'true',
+                };
+                // POST to get ws_url for signaling
+                const res = yield fetch(postUrl, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify({
                         bot_id: botId,
                         conversation_id: conversationId,
                         voice: 'alloy',
-                    },
+                    }),
                 });
+                if (!res.ok) {
+                    throw new Error(`HTTP ${res.status}`);
+                }
+                const json = yield res.json();
+                const wsUrl = json === null || json === void 0 ? void 0 : json.rn_ws_url;
+                if (!wsUrl || typeof wsUrl !== 'string') {
+                    throw new Error('No ws_url in response');
+                }
+                // Subscribe to room_created BEFORE connecting to avoid race
+                this.wsClient.roomCreated$
+                    .pipe(take(1), takeUntil(this.destroy$))
+                    .subscribe((roomUrl) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        yield this.onRoomCreated(roomUrl);
+                    }
+                    catch (err) {
+                        console.error('Daily join failed:', err);
+                        this.callStateSubject.next('ended');
+                        this.statusTextSubject.next('Connection failed');
+                        yield this.disconnect();
+                        throw err;
+                    }
+                }));
+                // Forward transcripts from WebSocket
+                this.subscriptions.add(this.wsClient.userTranscript$
+                    .pipe(takeUntil(this.destroy$))
+                    .subscribe((t) => this.userTranscriptSubject.next(t)));
+                this.subscriptions.add(this.wsClient.botTranscript$
+                    .pipe(takeUntil(this.destroy$))
+                    .subscribe((t) => this.botTranscriptSubject.next(t)));
+                // Connect signaling WebSocket (no audio over WS)
+                this.wsClient.connect(wsUrl);
             }
             catch (error) {
-                console.error('[HiveGpt Voice] connect failed', error);
+                console.error('Error connecting voice agent:', error);
                 this.callStateSubject.next('ended');
-                yield this.cleanupPipecatClient();
+                yield this.disconnect();
                 this.statusTextSubject.next('Connection failed');
                 throw error;
             }
         });
     }
-    onPipecatConnected() {
-        this.callStateSubject.next('connected');
-        this.statusTextSubject.next('Connected');
-        this.isMicMutedSubject.next(false);
-        this.startLocalMicAnalyzer();
-    }
-    onPipecatDisconnected() {
-        this.stopDurationTimer();
-        this.callStartTime = 0;
-        this.audioAnalyzer.stop();
-        this.stopBotAudio();
-        this.callStateSubject.next('ended');
-        this.statusTextSubject.next('Call Ended');
-    }
-    onBotReady() {
-        var _a, _b, _c;
-        // Retry track wiring in case tracks weren't ready at onConnected
-        this.startLocalMicAnalyzer();
-        const botTrack = (_c = (_b = (_a = this.pcClient) === null || _a === void 0 ? void 0 : _a.tracks()) === null || _b === void 0 ? void 0 : _b.bot) === null || _c === void 0 ? void 0 : _c.audio;
-        if (botTrack)
-            this.setupBotAudioTrack(botTrack);
-    }
-    startLocalMicAnalyzer() {
-        var _a, _b, _c;
-        const localTrack = (_c = (_b = (_a = this.pcClient) === null || _a === void 0 ? void 0 : _a.tracks()) === null || _b === void 0 ? void 0 : _b.local) === null || _c === void 0 ? void 0 : _c.audio;
-        if (localTrack) {
-            this.audioAnalyzer.start(new MediaStream([localTrack]));
-        }
-    }
-    onBotStartedSpeaking() {
-        if (this.callStartTime === 0) {
-            this.callStartTime = Date.now();
-            this.startDurationTimer();
-        }
-        this.callStateSubject.next('talking');
-    }
-    onBotStoppedSpeaking() {
-        if (this.callStateSubject.value === 'talking') {
-            this.callStateSubject.next('connected');
-        }
-    }
-    setupBotAudioTrack(track) {
-        var _a;
-        if (!this.botAudioElement) {
-            this.botAudioElement = new Audio();
-            this.botAudioElement.autoplay = true;
-        }
-        const existing = (_a = this.botAudioElement.srcObject) === null || _a === void 0 ? void 0 : _a.getAudioTracks()[0];
-        if ((existing === null || existing === void 0 ? void 0 : existing.id) === track.id)
-            return;
-        this.botAudioElement.srcObject = new MediaStream([track]);
-        this.botAudioElement.play().catch((err) => console.warn('[HiveGpt Voice] Bot audio play blocked', err));
-    }
-    stopBotAudio() {
-        var _a;
-        if (this.botAudioElement) {
-            try {
-                this.botAudioElement.pause();
-                (_a = this.botAudioElement.srcObject) === null || _a === void 0 ? void 0 : _a.getAudioTracks().forEach((t) => t.stop());
-                this.botAudioElement.srcObject = null;
-            }
-            catch (_b) {
-                // ignore
-            }
-            this.botAudioElement = null;
-        }
+    onRoomCreated(roomUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Connect Daily.js for WebRTC audio
+            yield this.dailyClient.connect(roomUrl);
+            this.hasAutoUnmutedAfterFirstAudio = false;
+            // Waveform: use local mic stream from Daily client
+            this.dailyClient.localStream$
+                .pipe(filter((s) => s != null), take(1))
+                .subscribe((stream) => {
+                this.audioAnalyzer.start(stream);
+            });
+            this.subscriptions.add(this.dailyClient.userSpeaking$.subscribe((s) => this.isUserSpeakingSubject.next(s)));
+            this.subscriptions.add(combineLatest([
+                this.dailyClient.speaking$,
+                this.dailyClient.userSpeaking$,
+            ]).subscribe(([bot, user]) => {
+                const current = this.callStateSubject.value;
+                if (current === 'connecting' && !bot) {
+                    return;
+                }
+                if (current === 'connecting' && bot) {
+                    this.callStartTime = Date.now();
+                    this.startDurationTimer();
+                    this.callStateSubject.next('talking');
+                    return;
+                }
+                if (user) {
+                    this.callStateSubject.next('listening');
+                }
+                else if (bot) {
+                    this.callStateSubject.next('talking');
+                }
+                else if (current === 'talking' || current === 'listening') {
+                    this.callStateSubject.next('connected');
+                }
+            }));
+            this.subscriptions.add(this.dailyClient.micMuted$.subscribe((muted) => this.isMicMutedSubject.next(muted)));
+            // One-time auto-unmute after first remote audio frame starts playing.
+            // This keeps initial capture muted until bot audio is heard, then restores normal mic flow.
+            this.subscriptions.add(this.dailyClient.firstRemoteAudioFrame$
+                .pipe(filter((hasFirstFrame) => hasFirstFrame), take(1))
+                .subscribe(() => {
+                if (this.hasAutoUnmutedAfterFirstAudio)
+                    return;
+                this.hasAutoUnmutedAfterFirstAudio = true;
+                if (this.isMicMutedSubject.value) {
+                    this.dailyClient.setMuted(false);
+                }
+            }));
+            this.statusTextSubject.next('Connecting...');
+        });
     }
     disconnect() {
         return __awaiter(this, void 0, void 0, function* () {
             this.stopDurationTimer();
-            this.callStartTime = 0;
             this.audioAnalyzer.stop();
-            this.stopBotAudio();
-            yield this.cleanupPipecatClient();
+            // Daily first, then WebSocket
+            yield this.dailyClient.disconnect();
+            this.wsClient.disconnect();
             this.callStateSubject.next('ended');
             this.statusTextSubject.next('Call Ended');
-        });
-    }
-    cleanupPipecatClient() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.pcClient) {
-                try {
-                    yield this.pcClient.disconnect();
-                }
-                catch (_a) {
-                    // ignore
-                }
-                this.pcClient = null;
-            }
+            this.hasAutoUnmutedAfterFirstAudio = false;
         });
     }
     toggleMic() {
-        if (!this.pcClient)
-            return;
-        const nextMuted = !this.isMicMutedSubject.value;
-        this.pcClient.enableMic(!nextMuted);
-        this.isMicMutedSubject.next(nextMuted);
-        if (nextMuted)
-            this.isUserSpeakingSubject.next(false);
+        const current = this.isMicMutedSubject.value;
+        this.dailyClient.setMuted(!current);
     }
     startDurationTimer() {
-        const tick = () => {
+        const updateDuration = () => {
             if (this.callStartTime > 0) {
                 const elapsed = Math.floor((Date.now() - this.callStartTime) / 1000);
-                const m = Math.floor(elapsed / 60);
-                const s = elapsed % 60;
-                this.durationSubject.next(`${m}:${String(s).padStart(2, '0')}`);
+                const minutes = Math.floor(elapsed / 60);
+                const seconds = elapsed % 60;
+                this.durationSubject.next(`${minutes}:${String(seconds).padStart(2, '0')}`);
             }
         };
-        tick();
-        this.durationInterval = setInterval(tick, 1000);
+        updateDuration();
+        this.durationInterval = setInterval(updateDuration, 1000);
     }
     stopDurationTimer() {
         if (this.durationInterval) {
@@ -1077,7 +1446,7 @@ class VoiceAgentService {
         }
     }
 }
-VoiceAgentService.ɵprov = i0.ɵɵdefineInjectable({ factory: function VoiceAgentService_Factory() { return new VoiceAgentService(i0.ɵɵinject(AudioAnalyzerService), i0.ɵɵinject(PlatformTokenRefreshService), i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i0.PLATFORM_ID)); }, token: VoiceAgentService, providedIn: "root" });
+VoiceAgentService.ɵprov = i0.ɵɵdefineInjectable({ factory: function VoiceAgentService_Factory() { return new VoiceAgentService(i0.ɵɵinject(AudioAnalyzerService), i0.ɵɵinject(WebSocketVoiceClientService), i0.ɵɵinject(DailyVoiceClientService), i0.ɵɵinject(PlatformTokenRefreshService), i0.ɵɵinject(i0.PLATFORM_ID)); }, token: VoiceAgentService, providedIn: "root" });
 VoiceAgentService.decorators = [
     { type: Injectable, args: [{
                 providedIn: 'root',
@@ -1085,8 +1454,9 @@ VoiceAgentService.decorators = [
 ];
 VoiceAgentService.ctorParameters = () => [
     { type: AudioAnalyzerService },
+    { type: WebSocketVoiceClientService },
+    { type: DailyVoiceClientService },
     { type: PlatformTokenRefreshService },
-    { type: NgZone },
     { type: Object, decorators: [{ type: Inject, args: [PLATFORM_ID,] }] }
 ];
 
@@ -5125,8 +5495,8 @@ ChatBotComponent.propDecorators = {
 };
 
 /**
- * Voice agent module. Uses @pipecat-ai/client-js + @pipecat-ai/websocket-transport
- * (peer dependencies) for WebSocket transport, RTVI protocol, and audio.
+ * Voice agent module. Uses native WebSocket + Daily.js only.
+ * Does NOT use Socket.IO or ngx-socket-io.
  */
 class VoiceAgentModule {
 }
@@ -5141,6 +5511,8 @@ VoiceAgentModule.decorators = [
                 providers: [
                     VoiceAgentService,
                     AudioAnalyzerService,
+                    WebSocketVoiceClientService,
+                    DailyVoiceClientService
                 ],
                 exports: [
                     VoiceAgentModalComponent
@@ -5411,5 +5783,5 @@ HiveGptModule.decorators = [
  * Generated bundle index. Do not edit.
  */
 
-export { AudioAnalyzerService, ChatBotComponent, ChatDrawerComponent, HIVEGPT_AUTH_STORAGE_KEY, HiveGptModule, PlatformTokenRefreshService, VOICE_MODAL_CLOSE_CALLBACK, VOICE_MODAL_CONFIG, VoiceAgentModalComponent, VoiceAgentModule, VoiceAgentService, eClassificationType, hiveGptAuthStorageKeyFactory, BotsService as ɵa, SocketService as ɵb, ConversationService as ɵc, NotificationSocket as ɵd, TranslationService as ɵe, VideoPlayerComponent as ɵf, SafeHtmlPipe as ɵg, BotHtmlEditorComponent as ɵh };
+export { AudioAnalyzerService, ChatBotComponent, ChatDrawerComponent, HIVEGPT_AUTH_STORAGE_KEY, HiveGptModule, PlatformTokenRefreshService, VOICE_MODAL_CLOSE_CALLBACK, VOICE_MODAL_CONFIG, VoiceAgentModalComponent, VoiceAgentModule, VoiceAgentService, eClassificationType, hiveGptAuthStorageKeyFactory, BotsService as ɵa, SocketService as ɵb, ConversationService as ɵc, NotificationSocket as ɵd, TranslationService as ɵe, WebSocketVoiceClientService as ɵf, DailyVoiceClientService as ɵg, VideoPlayerComponent as ɵh, SafeHtmlPipe as ɵi, BotHtmlEditorComponent as ɵj };
 //# sourceMappingURL=hivegpt-hiveai-angular.js.map