@voxagent/bridge 0.4.1 → 0.6.0

package/dist/live/frontend.d.ts

@@ -0,0 +1,136 @@
+/**
+ * @file GPT-Live as the agent's voice: ears, mouth and turn-taking.
+ *
+ * In `--voice-mode live` the bridge stops being text-in/TTS-out. Instead:
+ *
+ *   room mics ──► PcmMixer ──► GPT-Live (one mixed stream) ──► agent track
+ *        │                       │  │
+ *        └► SpeakerTracker ──────┘  └─ session.delegation.created
+ *           ("Now speaking: David")        │
+ *                                          ▼
+ *                     BridgeRoomRuntime runs Claude Code / Codex, then
+ *                     reports progress (thinking) and the result
+ *                     (commentary) back to GPT-Live, which says it.
+ *
+ * GPT-Live decides when to talk, handles barge-in and backchannels, and
+ * picks what to hand off. This class owns everything GPT-Live-specific;
+ * `room.ts` only sees delegations and reports outcomes.
+ */
+import { type Room } from '@livekit/rtc-node';
+import { type TranscriptFinalEvent, type TranscriptWindowEntry } from '../protocol.js';
+import { type LiveSocketFactory } from './session.js';
+export interface LiveDelegation {
+    /** GPT-Live delegation ID; results must quote it. */
+    id: string;
+    /** User turn for the backend, built from what GPT-Live heard. */
+    promptText: string;
+    /** The same hand-off phrased for an agent already working (added to its run). */
+    followUpText: string;
+    /** Best guess at who asked, from the speaker timeline. */
+    requester: {
+        name: string;
+        identity: string;
+    } | null;
+    /** Speaker-attributed browser finals for the prompt's transcript window. */
+    roomTranscript: TranscriptWindowEntry[];
+    room: {
+        id: string;
+        name: string;
+        participants: string[];
+    };
+}
+export interface LiveVoiceFrontendOptions {
+    room: Room;
+    apiKey: string;
+    model: string;
+    voice: string;
+    instructions: string;
+    assistantName: string;
+    roomId: string;
+    /** Pair payload's room name — currently the room ID, so finals' names win. */
+    roomName: string;
+    hostIdentity: string | null;
+    onDelegation: (delegation: LiveDelegation) => void;
+    /** Test seam. */
+    socketFactory?: LiveSocketFactory;
+}
+export declare class LiveVoiceFrontend {
+    private readonly options;
+    private session;
+    /** Bumped per GPT-Live session; delegation IDs don't survive a reconnect. */
+    private generation;
+    private delegationGeneration;
+    private lastProgressAt;
+    private readonly mixer;
+    private readonly tracker;
+    private readonly transcript;
+    private readonly publisher;
+    private readonly outputChunker;
+    private playback;
+    private captures;
+    private names;
+    private roomFinals;
+    private roomName;
+    private participants;
+    private clock;
+    private clockOrigin;
+    private clockSamples;
+    /** Mixed audio sent to the current session = its timeline position. */
+    private sessionSamples;
+    private lastDelegationMs;
+    /** Transcript lines already written to the log (the meeting's paper trail). */
+    private loggedLines;
+    private muted;
+    private closing;
+    private reconnectAttempt;
+    private reconnectTimer;
+    private rosterTimer;
+    constructor(options: LiveVoiceFrontendOptions);
+    start(): Promise<void>;
+    close(): Promise<void>;
+    /** System-prompt addendum for a backend run this front end started. */
+    backendAddendum(): string;
+    /** Browser STT finals: reliable speaker labels for the backend prompt. */
+    noteRoomFinal(event: TranscriptFinalEvent): void;
+    /** Quiet progress for a delegated task ("Running the tests."). Rate-limited. */
+    reportProgress(delegationId: string | null, text: string): void;
+    /** The backend's final reply, for GPT-Live to relay in its own words. */
+    reportResult(delegationId: string | null, text: string): void;
+    reportFailure(delegationId: string | null, message: string): void;
+    /** Something the room should hear now, not tied to a task. */
+    say(text: string): void;
+    /** The UI's Stop button: cut speech now and tell GPT-Live why. */
+    stopSpeaking(taskCancelled: boolean): void;
+    /** Room-wide agent mute: stop listening and speaking, keep the session. */
+    setMuted(muted: boolean): void;
+    private openSession;
+    private handleSessionEvent;
+    private scheduleReconnect;
+    /** Recent conversation as text history for a replacement session. */
+    private buildSeedHistory;
+    private emitDelegation;
+    /** Delegation IDs belong to one session; after a reconnect report as general context. */
+    private liveDelegationId;
+    private forgetDelegation;
+    private tick;
+    private sendBlock;
+    private handleTrackSubscribed;
+    private handleTrackUnsubscribed;
+    private handleParticipantDisconnected;
+    private handleRosterChange;
+    private maybeCapture;
+    private pumpCapture;
+    private stopCapture;
+    private playAudio;
+    private dropQueuedOutput;
+    /**
+     * Writes finished transcript lines to the log: what GPT-Live heard (with
+     * the tracker's speaker label) and what it said. Lines still growing
+     * (touched within LOG_LINE_AFTER_MS of `beforeMs`) wait for a later pass.
+     */
+    private logTranscript;
+    private nameOf;
+    private humanNames;
+    private sendRoster;
+}
+//# sourceMappingURL=frontend.d.ts.map

package/dist/live/frontend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontend.d.ts","sourceRoot":"","sources":["../../src/live/frontend.ts"],"names":[],"mappings":"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"}

package/dist/live/frontend.js

@@ -0,0 +1,529 @@
+/**
+ * @file GPT-Live as the agent's voice: ears, mouth and turn-taking.
+ *
+ * In `--voice-mode live` the bridge stops being text-in/TTS-out. Instead:
+ *
+ *   room mics ──► PcmMixer ──► GPT-Live (one mixed stream) ──► agent track
+ *        │                       │  │
+ *        └► SpeakerTracker ──────┘  └─ session.delegation.created
+ *           ("Now speaking: David")        │
+ *                                          ▼
+ *                     BridgeRoomRuntime runs Claude Code / Codex, then
+ *                     reports progress (thinking) and the result
+ *                     (commentary) back to GPT-Live, which says it.
+ *
+ * GPT-Live decides when to talk, handles barge-in and backchannels, and
+ * picks what to hand off. This class owns everything GPT-Live-specific;
+ * `room.ts` only sees delegations and reports outcomes.
+ */
+import { AudioStream, RoomEvent, TrackKind, TrackSource, } from '@livekit/rtc-node';
+import { AgentAudioPublisher } from '../audio/source.js';
+import { log } from '../logging.js';
+import { isAgentIdentity } from '../protocol.js';
+import { PcmMixer } from './mixer.js';
+import { LIVE_SAMPLE_RATE, PcmChunker, SAMPLES_PER_MS } from './pcm.js';
+import { buildBackendAddendum, buildDelegationPrompt, buildFollowUpPrompt, nowSpeakingHint, rosterHint, splitForAppend, } from './prompts.js';
+import { LiveSession, } from './session.js';
+import { SpeakerTracker } from './speakers.js';
+import { LiveTranscript, formatLine, pickDelegationContext, } from './transcript.js';
+/** Mixed audio goes to GPT-Live in 40 ms blocks. */
+const BLOCK_SAMPLES = 40 * SAMPLES_PER_MS;
+/** Output frames into LiveKit, matching the TTS engines' 20 ms framing. */
+const OUTPUT_FRAME_SAMPLES = 20 * SAMPLES_PER_MS;
+const CLOCK_INTERVAL_MS = 20;
+/** Past this much lag (event-loop stall) the clock skips ahead instead of bursting. */
+const MAX_CATCHUP_SAMPLES = 400 * SAMPLES_PER_MS;
+/** Per-source backlog cap — bounds added latency from jitter and drift. */
+const MAX_SOURCE_BACKLOG_SAMPLES = 300 * SAMPLES_PER_MS;
+/** Let trailing transcript fragments land before building a delegation prompt. */
+const DELEGATION_SETTLE_MS = 250;
+const PROGRESS_MIN_GAP_MS = 5_000;
+const ROOM_FINALS_KEPT = 16;
+const SEED_MAX_MESSAGES = 60;
+const SEED_MAX_CHARS = 20_000;
+const RECONNECT_DELAYS_MS = [500, 2_000, 5_000, 10_000, 20_000];
+/** A transcript line is logged once nothing has been added to it for this long. */
+const LOG_LINE_AFTER_MS = 2_500;
+export class LiveVoiceFrontend {
+    options;
+    session = null;
+    /** Bumped per GPT-Live session; delegation IDs don't survive a reconnect. */
+    generation = 0;
+    delegationGeneration = new Map();
+    lastProgressAt = new Map();
+    mixer = new PcmMixer({ maxBufferedSamples: MAX_SOURCE_BACKLOG_SAMPLES });
+    tracker = new SpeakerTracker();
+    transcript = new LiveTranscript();
+    publisher = new AgentAudioPublisher(LIVE_SAMPLE_RATE, 1);
+    outputChunker = new PcmChunker(OUTPUT_FRAME_SAMPLES);
+    playback = Promise.resolve();
+    captures = new Map();
+    names = new Map();
+    roomFinals = [];
+    roomName;
+    participants = [];
+    clock = null;
+    clockOrigin = 0;
+    clockSamples = 0;
+    /** Mixed audio sent to the current session = its timeline position. */
+    sessionSamples = 0;
+    lastDelegationMs = 0;
+    /** Transcript lines already written to the log (the meeting's paper trail). */
+    loggedLines = new WeakSet();
+    muted = false;
+    closing = false;
+    reconnectAttempt = 0;
+    reconnectTimer = null;
+    rosterTimer = null;
+    constructor(options) {
+        this.options = options;
+        this.roomName = options.roomName;
+    }
+    async start() {
+        const { room } = this.options;
+        await this.publisher.publish(room);
+        room.on(RoomEvent.TrackSubscribed, this.handleTrackSubscribed);
+        room.on(RoomEvent.TrackUnsubscribed, this.handleTrackUnsubscribed);
+        room.on(RoomEvent.ParticipantConnected, this.handleRosterChange);
+        room.on(RoomEvent.ParticipantDisconnected, this.handleParticipantDisconnected);
+        for (const participant of room.remoteParticipants.values()) {
+            for (const publication of participant.trackPublications.values()) {
+                if (publication.track)
+                    this.maybeCapture(publication.track, publication, participant);
+            }
+        }
+        this.clockOrigin = performance.now();
+        this.clockSamples = 0;
+        this.clock = setInterval(this.tick, CLOCK_INTERVAL_MS);
+        await this.openSession([]);
+    }
+    async close() {
+        if (this.closing)
+            return;
+        this.closing = true;
+        if (this.clock)
+            clearInterval(this.clock);
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        if (this.rosterTimer)
+            clearTimeout(this.rosterTimer);
+        const { room } = this.options;
+        room.off(RoomEvent.TrackSubscribed, this.handleTrackSubscribed);
+        room.off(RoomEvent.TrackUnsubscribed, this.handleTrackUnsubscribed);
+        room.off(RoomEvent.ParticipantConnected, this.handleRosterChange);
+        room.off(RoomEvent.ParticipantDisconnected, this.handleParticipantDisconnected);
+        for (const key of [...this.captures.keys()])
+            this.stopCapture(key);
+        this.logTranscript(Number.POSITIVE_INFINITY);
+        await this.session?.close();
+        await this.publisher.close();
+    }
+    // ---------------------------------------------------------------------
+    // Called by the room runtime
+    // ---------------------------------------------------------------------
+    /** System-prompt addendum for a backend run this front end started. */
+    backendAddendum() {
+        return buildBackendAddendum({
+            assistantName: this.options.assistantName,
+            roomName: this.roomName,
+            participants: this.participants,
+        });
+    }
+    /** Browser STT finals: reliable speaker labels for the backend prompt. */
+    noteRoomFinal(event) {
+        if (event.room?.name)
+            this.roomName = event.room.name;
+        if (event.room?.participants?.length)
+            this.participants = event.room.participants;
+        this.roomFinals.push({ speaker: event.speaker, text: event.text, timestampMs: event.timestampMs });
+        if (this.roomFinals.length > ROOM_FINALS_KEPT)
+            this.roomFinals.shift();
+    }
+    /** Quiet progress for a delegated task ("Running the tests."). Rate-limited. */
+    reportProgress(delegationId, text) {
+        const key = delegationId ?? '';
+        const now = Date.now();
+        if (now - (this.lastProgressAt.get(key) ?? 0) < PROGRESS_MIN_GAP_MS)
+            return;
+        this.lastProgressAt.set(key, now);
+        this.session?.appendThinking(`Backend progress: ${text}`, this.liveDelegationId(delegationId));
+    }
+    /** The backend's final reply, for GPT-Live to relay in its own words. */
+    reportResult(delegationId, text) {
+        const chunks = splitForAppend(text);
+        const target = this.liveDelegationId(delegationId);
+        log.info('live_result', { delegationId, sentAs: target ?? 'general context', chunks: chunks.length, text: text.slice(0, 600) });
+        if (chunks.length === 0) {
+            this.session?.appendCommentary('The agent finished but did not return a summary.', target);
+        }
+        for (const chunk of chunks)
+            this.session?.appendCommentary(chunk, target);
+        if (delegationId)
+            this.forgetDelegation(delegationId);
+    }
+    reportFailure(delegationId, message) {
+        log.info('live_result_failed', { delegationId, message: message.slice(0, 300) });
+        const detail = message.trim() ? ` ${message.trim().slice(0, 300)}` : '';
+        this.session?.appendCommentary(`The agent could not finish that task.${detail}`, this.liveDelegationId(delegationId));
+        if (delegationId)
+            this.forgetDelegation(delegationId);
+    }
+    /** Something the room should hear now, not tied to a task. */
+    say(text) {
+        this.session?.appendCommentary(text, null);
+    }
+    /** The UI's Stop button: cut speech now and tell GPT-Live why. */
+    stopSpeaking(taskCancelled) {
+        this.dropQueuedOutput();
+        this.session?.appendInstructions(`Someone pressed Stop. Stop speaking immediately and wait to be addressed.${taskCancelled ? ' The task you delegated was cancelled; do not report on it.' : ''}`);
+    }
+    /** Room-wide agent mute: stop listening and speaking, keep the session. */
+    setMuted(muted) {
+        if (muted === this.muted)
+            return;
+        this.muted = muted;
+        log.info('live_mute_changed', { muted });
+        this.session?.setInputMuted(muted);
+        if (muted)
+            this.dropQueuedOutput();
+    }
+    // ---------------------------------------------------------------------
+    // Session lifecycle
+    // ---------------------------------------------------------------------
+    async openSession(input) {
+        const generation = ++this.generation;
+        const session = new LiveSession({
+            apiKey: this.options.apiKey,
+            model: this.options.model,
+            voice: this.options.voice,
+            instructions: this.options.instructions,
+            input,
+        }, (event) => this.handleSessionEvent(generation, event), this.options.socketFactory);
+        this.session = session;
+        await session.start();
+        this.reconnectAttempt = 0;
+        if (this.muted)
+            session.setInputMuted(true);
+        this.sendRoster();
+    }
+    handleSessionEvent(generation, event) {
+        if (generation !== this.generation)
+            return;
+        switch (event.type) {
+            case 'started':
+                // New session timeline: everything time-based restarts at 0.
+                this.sessionSamples = 0;
+                this.lastDelegationMs = 0;
+                this.tracker.reset();
+                this.outputChunker.reset();
+                log.info('live_session_started', {
+                    sessionId: event.sessionId,
+                    expiresInS: event.expiresAt ? Math.round(event.expiresAt - Date.now() / 1000) : null,
+                    generation,
+                });
+                return;
+            case 'audio':
+                this.playAudio(event.samples);
+                return;
+            case 'transcript':
+                this.logTranscript(event.startMs - LOG_LINE_AFTER_MS);
+                if (event.role === 'input') {
+                    const speakerId = this.tracker.speakerAt(event.startMs, event.endMs);
+                    const name = speakerId ? this.nameOf(speakerId) : null;
+                    this.transcript.addFragment('room', name, event.delta, event.startMs, event.endMs);
+                }
+                else {
+                    this.transcript.addFragment('assistant', null, event.delta, event.startMs, event.endMs);
+                }
+                return;
+            case 'delegation':
+                this.delegationGeneration.set(event.id, generation);
+                setTimeout(() => this.emitDelegation(event.id, event.offsetMs), DELEGATION_SETTLE_MS);
+                return;
+            case 'usage':
+                log.debug('live_usage', { seconds: event.seconds, contextRatio: event.contextRatio });
+                return;
+            case 'error':
+                log.warn('live_error', { code: event.code, message: event.message, clientEventId: event.clientEventId });
+                return;
+            case 'closed':
+                this.logTranscript(Number.POSITIVE_INFINITY);
+                log.info('live_session_closed', { reason: event.reason, usageSeconds: event.usageSeconds });
+                if (!this.closing)
+                    this.scheduleReconnect(event.reason);
+                return;
+            default: {
+                const exhaustive = event;
+                log.warn('live_unknown_event', { event: exhaustive });
+            }
+        }
+    }
+    scheduleReconnect(reason) {
+        if (this.reconnectTimer)
+            return;
+        const attempt = this.reconnectAttempt++;
+        const delay = reason === 'expired' ? 0 : RECONNECT_DELAYS_MS[Math.min(attempt, RECONNECT_DELAYS_MS.length - 1)];
+        log.warn('live_session_reconnecting', { reason, attempt: attempt + 1, delayMs: delay });
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            if (this.closing)
+                return;
+            const seed = this.buildSeedHistory();
+            this.transcript.clear();
+            this.openSession(seed).catch((error) => {
+                log.error('live_session_start_failed', {
+                    message: error instanceof Error ? error.message : String(error),
+                });
+                if (!this.closing)
+                    this.scheduleReconnect('connection_lost');
+            });
+        }, delay);
+    }
+    /** Recent conversation as text history for a replacement session. */
+    buildSeedHistory() {
+        const items = [];
+        let chars = 0;
+        const lines = this.transcript.recent(SEED_MAX_MESSAGES);
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i];
+            const text = line.role === 'assistant' ? line.text.trim() : formatLine(line, this.options.assistantName);
+            if (!text)
+                continue;
+            chars += text.length;
+            if (chars > SEED_MAX_CHARS)
+                break;
+            items.unshift(line.role === 'assistant'
+                ? { type: 'message', role: 'assistant', content: [{ type: 'output_text', text }] }
+                : { type: 'message', role: 'user', content: [{ type: 'input_text', text }] });
+        }
+        if (items.length > 0) {
+            items.unshift({
+                type: 'message',
+                role: 'developer',
+                content: [
+                    {
+                        type: 'input_text',
+                        text: 'The voice connection was restarted. The messages below are the recent meeting conversation. Continue without greeting anyone again.',
+                    },
+                ],
+            });
+        }
+        return items;
+    }
+    emitDelegation(id, offsetMs) {
+        const { heard, requester } = pickDelegationContext(this.transcript, this.lastDelegationMs, offsetMs);
+        // For an agent already at work: only what's new since the last hand-off.
+        const sinceLast = this.transcript.linesSince(this.lastDelegationMs);
+        const followUpHeard = sinceLast.length > 0 ? sinceLast : this.transcript.recent(2);
+        this.lastDelegationMs = Math.max(this.lastDelegationMs, offsetMs);
+        const requesterIdentity = requester
+            ? [...this.names.entries()].find(([, name]) => name === requester)?.[0] ?? null
+            : null;
+        const delegation = {
+            id,
+            promptText: buildDelegationPrompt({
+                assistantName: this.options.assistantName,
+                heard,
+                roomTranscript: this.roomFinals,
+            }),
+            followUpText: buildFollowUpPrompt({
+                assistantName: this.options.assistantName,
+                heard: followUpHeard,
+                requester,
+            }),
+            requester: requester && requesterIdentity ? { name: requester, identity: requesterIdentity } : null,
+            roomTranscript: [...this.roomFinals],
+            room: {
+                id: this.options.roomId,
+                name: this.roomName,
+                participants: this.participants.length > 0 ? this.participants : this.humanNames(),
+            },
+        };
+        this.logTranscript(Number.POSITIVE_INFINITY);
+        log.info('live_delegation', {
+            id,
+            offsetMs,
+            requester: delegation.requester?.name ?? null,
+            heardLines: heard.length,
+        });
+        log.info('live_delegation_prompt', { id, prompt: delegation.promptText });
+        this.options.onDelegation(delegation);
+    }
+    /** Delegation IDs belong to one session; after a reconnect report as general context. */
+    liveDelegationId(delegationId) {
+        if (!delegationId)
+            return null;
+        return this.delegationGeneration.get(delegationId) === this.generation ? delegationId : null;
+    }
+    forgetDelegation(delegationId) {
+        this.delegationGeneration.delete(delegationId);
+        this.lastProgressAt.delete(delegationId);
+    }
+    // ---------------------------------------------------------------------
+    // Audio in: room mics → mixer → GPT-Live
+    // ---------------------------------------------------------------------
+    tick = () => {
+        const target = Math.floor((performance.now() - this.clockOrigin) * SAMPLES_PER_MS);
+        if (target - this.clockSamples > MAX_CATCHUP_SAMPLES) {
+            log.debug('live_clock_skip', { lagMs: Math.round((target - this.clockSamples) / SAMPLES_PER_MS) });
+            this.clockSamples = target - BLOCK_SAMPLES;
+        }
+        while (this.clockSamples + BLOCK_SAMPLES <= target) {
+            this.clockSamples += BLOCK_SAMPLES;
+            this.sendBlock(this.mixer.pull(BLOCK_SAMPLES));
+        }
+    };
+    sendBlock(block) {
+        const session = this.session;
+        if (!session?.started)
+            return;
+        session.appendAudio(block.mixed);
+        this.sessionSamples += BLOCK_SAMPLES;
+        // Sources are per track; the floor is per person.
+        const byIdentity = new Map();
+        for (const [sourceId, level] of block.levels) {
+            const identity = this.captures.get(sourceId)?.identity;
+            if (!identity)
+                continue;
+            byIdentity.set(identity, Math.max(byIdentity.get(identity) ?? 0, level));
+        }
+        const announce = this.tracker.update(byIdentity, this.sessionSamples / SAMPLES_PER_MS);
+        if (announce && !this.muted && this.humanNames().length > 1) {
+            const hint = nowSpeakingHint(this.nameOf(announce), announce === this.options.hostIdentity);
+            log.info('live_hint', { atMs: Math.round(this.sessionSamples / SAMPLES_PER_MS), hint });
+            session.appendThinking(hint);
+        }
+    }
+    handleTrackSubscribed = (track, publication, participant) => {
+        this.maybeCapture(track, publication, participant);
+    };
+    handleTrackUnsubscribed = (_track, publication, participant) => {
+        this.stopCapture(sourceKey(participant.identity, publication.sid));
+    };
+    handleParticipantDisconnected = (participant) => {
+        for (const [key, capture] of this.captures) {
+            if (capture.identity === participant.identity)
+                this.stopCapture(key);
+        }
+        this.handleRosterChange();
+    };
+    handleRosterChange = () => {
+        if (this.rosterTimer)
+            clearTimeout(this.rosterTimer);
+        this.rosterTimer = setTimeout(() => {
+            this.rosterTimer = null;
+            this.sendRoster();
+        }, 1_000);
+    };
+    maybeCapture(track, publication, participant) {
+        // Humans' microphones only. Agents (including other bridges, later) are
+        // never mixed in: an agent hearing agents is how feedback loops start.
+        if (isAgentIdentity(participant.identity))
+            return;
+        if (track.kind !== TrackKind.KIND_AUDIO)
+            return;
+        if (publication.source !== TrackSource.SOURCE_MICROPHONE)
+            return;
+        const key = sourceKey(participant.identity, publication.sid);
+        if (this.captures.has(key))
+            return;
+        this.names.set(participant.identity, participant.name || participant.identity);
+        const stream = new AudioStream(track, { sampleRate: LIVE_SAMPLE_RATE, numChannels: 1 });
+        const capture = { identity: participant.identity, stream, reader: null };
+        this.captures.set(key, capture);
+        log.info('live_capture_started', { identity: participant.identity, name: this.nameOf(participant.identity) });
+        void this.pumpCapture(key, capture);
+        this.handleRosterChange();
+    }
+    async pumpCapture(key, capture) {
+        const reader = capture.stream.getReader();
+        capture.reader = reader;
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done || !value)
+                    break;
+                this.mixer.push(key, value.data);
+            }
+        }
+        catch (error) {
+            log.debug('live_capture_ended', {
+                identity: capture.identity,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            if (this.captures.get(key) === capture)
+                this.stopCapture(key);
+        }
+    }
+    stopCapture(key) {
+        const capture = this.captures.get(key);
+        if (!capture)
+            return;
+        this.captures.delete(key);
+        this.mixer.remove(key);
+        void capture.reader?.cancel().catch(() => undefined);
+        log.info('live_capture_stopped', { identity: capture.identity });
+    }
+    // ---------------------------------------------------------------------
+    // Audio out: GPT-Live → agent track
+    // ---------------------------------------------------------------------
+    playAudio(samples) {
+        // GPT-Live streams continuously, silence included. While muted, drop it.
+        if (this.muted)
+            return;
+        for (const frame of this.outputChunker.push(samples)) {
+            this.playback = this.playback
+                .then(() => this.publisher.pushFrame({ samples: frame, sampleRate: LIVE_SAMPLE_RATE, numChannels: 1 }))
+                .catch((error) => {
+                log.debug('live_playback_failed', { message: error instanceof Error ? error.message : String(error) });
+            });
+        }
+    }
+    dropQueuedOutput() {
+        this.outputChunker.reset();
+        this.publisher.clearQueue();
+    }
+    // ---------------------------------------------------------------------
+    // People
+    // ---------------------------------------------------------------------
+    /**
+     * Writes finished transcript lines to the log: what GPT-Live heard (with
+     * the tracker's speaker label) and what it said. Lines still growing
+     * (touched within LOG_LINE_AFTER_MS of `beforeMs`) wait for a later pass.
+     */
+    logTranscript(beforeMs) {
+        for (const line of this.transcript.recent(40)) {
+            if (this.loggedLines.has(line) || line.endMs > beforeMs)
+                continue;
+            this.loggedLines.add(line);
+            log.info(line.role === 'assistant' ? 'live_said' : 'live_heard', {
+                atS: Math.round(line.startMs / 100) / 10,
+                ...(line.role === 'room' ? { speaker: line.speaker ?? 'unknown' } : {}),
+                text: line.text.trim(),
+            });
+        }
+    }
+    nameOf(identity) {
+        return this.names.get(identity) ?? identity;
+    }
+    humanNames() {
+        const names = [];
+        for (const participant of this.options.room.remoteParticipants.values()) {
+            if (isAgentIdentity(participant.identity))
+                continue;
+            const name = participant.name || participant.identity;
+            this.names.set(participant.identity, name);
+            names.push(participant.identity === this.options.hostIdentity ? `${name} (host)` : name);
+        }
+        return names;
+    }
+    sendRoster() {
+        this.session?.appendThinking(rosterHint(this.humanNames()));
+    }
+}
+function sourceKey(identity, trackSid) {
+    return `${identity}#${trackSid ?? 'mic'}`;
+}
+//# sourceMappingURL=frontend.js.map