@bytexbyte/nxtlinq-ai-agent-core-development 0.2.0

package/dist/voice/create-voice-session.js

@@ -0,0 +1,37 @@
+/**
+ * Step 1 of nxtlinq voice: mint session + TURN credentials (no WebRTC here).
+ */
+export async function createVoiceSession(baseUrl, params, fetchFn = globalThis.fetch) {
+    const url = `${baseUrl.replace(/\/+$/, '')}/api/voice/session`;
+    const sessionRes = await fetchFn(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            apiKey: params.apiKey,
+            apiSecret: params.apiSecret,
+            pseudoId: params.pseudoId,
+            externalId: params.externalId,
+            aitId: params.aitId,
+            walletAddress: params.walletAddress,
+            aitToken: params.aitToken,
+            voiceMode: params.voiceMode,
+            metadata: params.metadata,
+        }),
+    });
+    if (!sessionRes.ok) {
+        const errBody = await sessionRes.text().catch(() => '');
+        throw new Error(`Voice session creation failed: ${sessionRes.status} ${errBody}`);
+    }
+    const sessionData = (await sessionRes.json());
+    if (!sessionData.voiceSessionId ||
+        !sessionData.signalingUrl ||
+        !Array.isArray(sessionData.iceServers)) {
+        throw new Error('Voice session response missing required fields.');
+    }
+    return sessionData;
+}
+export function appendVoiceModeToSignalingUrl(signalingUrl, mode) {
+    const resolvedMode = mode === 'realtime' ? 'realtime' : 'cascade';
+    const sep = signalingUrl.includes('?') ? '&' : '?';
+    return `${signalingUrl}${sep}mode=${resolvedMode}`;
+}

package/dist/voice/output-audio-level.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Remote assistant audio RMS (0–1) for waveform UIs.
+ * Browser: AnalyserNode on WebRTC remote stream.
+ * React Native: RTCStatsReport audioLevel via PeerConnection.getStats().
+ */
+export type OutputAudioLevelMeter = {
+    getLevel(): number;
+    dispose(): void;
+};
+type PeerConnectionWithStats = {
+    getStats(): Promise<unknown>;
+};
+/**
+ * Poll inbound-rtp / media-source audioLevel from native RTCPeerConnection.
+ */
+export declare function createStatsOutputAudioLevelMeter(getPeerConnection: () => PeerConnectionWithStats | null): OutputAudioLevelMeter;
+/**
+ * Browser AnalyserNode tap on a remote MediaStream.
+ */
+export declare function createAnalyserOutputAudioLevelMeter(stream: MediaStream): OutputAudioLevelMeter | null;
+export declare function createOutputAudioLevelMeter(options: {
+    remoteStream: MediaStream | null;
+    getPeerConnection?: () => PeerConnectionWithStats | null;
+}): OutputAudioLevelMeter;
+export {};
+//# sourceMappingURL=output-audio-level.d.ts.map

package/dist/voice/output-audio-level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-audio-level.d.ts","sourceRoot":"","sources":["../../src/voice/output-audio-level.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,IAAI,MAAM,CAAC;IACnB,OAAO,IAAI,IAAI,CAAC;CACjB,CAAC;AAkBF,KAAK,uBAAuB,GAAG;IAC7B,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CAC9B,CAAC;AAEF;;GAEG;AACH,wBAAgB,gCAAgC,CAC9C,iBAAiB,EAAE,MAAM,uBAAuB,GAAG,IAAI,GACtD,qBAAqB,CAkDvB;AAED;;GAEG;AACH,wBAAgB,mCAAmC,CACjD,MAAM,EAAE,WAAW,GAClB,qBAAqB,GAAG,IAAI,CA6C9B;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE;IACnD,YAAY,EAAE,WAAW,GAAG,IAAI,CAAC;IACjC,iBAAiB,CAAC,EAAE,MAAM,uBAAuB,GAAG,IAAI,CAAC;CAC1D,GAAG,qBAAqB,CASxB"}

package/dist/voice/output-audio-level.js

@@ -0,0 +1,132 @@
+/**
+ * Remote assistant audio RMS (0–1) for waveform UIs.
+ * Browser: AnalyserNode on WebRTC remote stream.
+ * React Native: RTCStatsReport audioLevel via PeerConnection.getStats().
+ */
+const FFT_SIZE = 256;
+const STATS_POLL_MS = 200;
+function normalizeRms(sumSquares, count) {
+    if (count <= 0)
+        return 0;
+    const rms = Math.sqrt(sumSquares / count);
+    return Math.min(1, Math.max(0, rms * 4));
+}
+function normalizeStatsLevel(raw) {
+    if (!Number.isFinite(raw) || raw <= 0)
+        return 0;
+    // WebRTC stats often use 0–32767 (RFC); some browsers use 0–1.
+    const normalized = raw > 1 ? raw / 32767 : raw;
+    return Math.min(1, Math.max(0, normalized));
+}
+/**
+ * Poll inbound-rtp / media-source audioLevel from native RTCPeerConnection.
+ */
+export function createStatsOutputAudioLevelMeter(getPeerConnection) {
+    let level = 0;
+    let smoothed = 0;
+    let disposed = false;
+    let timer = null;
+    const poll = async () => {
+        const pc = getPeerConnection();
+        if (!pc || disposed)
+            return;
+        try {
+            const report = (await pc.getStats());
+            let best = 0;
+            const visit = (entry) => {
+                const t = entry.type;
+                if (t === 'inbound-rtp' || t === 'media-source' || t === 'track') {
+                    const audioLevel = entry.audioLevel;
+                    if (typeof audioLevel === 'number' && audioLevel > 0) {
+                        best = Math.max(best, normalizeStatsLevel(audioLevel));
+                    }
+                }
+            };
+            if (report instanceof Map) {
+                report.forEach((entry) => visit(entry));
+            }
+            else if (report && typeof report === 'object') {
+                for (const entry of Object.values(report)) {
+                    visit(entry);
+                }
+            }
+            smoothed = smoothed * 0.75 + best * 0.25;
+            level = smoothed;
+        }
+        catch {
+            /* ignore transient stats errors */
+        }
+    };
+    timer = setInterval(() => {
+        void poll();
+    }, STATS_POLL_MS);
+    void poll();
+    return {
+        getLevel: () => (disposed ? 0 : level),
+        dispose: () => {
+            disposed = true;
+            if (timer)
+                clearInterval(timer);
+            timer = null;
+            level = 0;
+            smoothed = 0;
+        },
+    };
+}
+/**
+ * Browser AnalyserNode tap on a remote MediaStream.
+ */
+export function createAnalyserOutputAudioLevelMeter(stream) {
+    const AudioCtx = typeof globalThis !== 'undefined'
+        ? globalThis.AudioContext
+        : undefined;
+    if (!AudioCtx)
+        return null;
+    let level = 0;
+    let disposed = false;
+    let rafId = 0;
+    const ctx = new AudioCtx();
+    const analyser = ctx.createAnalyser();
+    analyser.fftSize = FFT_SIZE;
+    const source = ctx.createMediaStreamSource(stream);
+    source.connect(analyser);
+    const data = new Uint8Array(analyser.frequencyBinCount);
+    const tick = () => {
+        if (disposed)
+            return;
+        analyser.getByteTimeDomainData(data);
+        let sum = 0;
+        for (let i = 0; i < data.length; i++) {
+            const v = (data[i] - 128) / 128;
+            sum += v * v;
+        }
+        level = normalizeRms(sum, data.length);
+        rafId = requestAnimationFrame(tick);
+    };
+    rafId = requestAnimationFrame(tick);
+    return {
+        getLevel: () => (disposed ? 0 : level),
+        dispose: () => {
+            disposed = true;
+            cancelAnimationFrame(rafId);
+            level = 0;
+            try {
+                source.disconnect();
+                analyser.disconnect();
+                void ctx.close();
+            }
+            catch {
+                /* noop */
+            }
+        },
+    };
+}
+export function createOutputAudioLevelMeter(options) {
+    const stream = options.remoteStream;
+    if (stream) {
+        const analyserMeter = createAnalyserOutputAudioLevelMeter(stream);
+        if (analyserMeter)
+            return analyserMeter;
+    }
+    return createStatsOutputAudioLevelMeter(options.getPeerConnection ?? (() => null));
+}

package/dist/voice/remote-audio-gain.d.ts

@@ -0,0 +1,10 @@
+import type { MediaStreamLike } from '../ports/WebRTCPort';
+/** react-native-webrtc `_setVolume` range; default 1.0 is quiet vs media-player TTS. */
+export declare const DEFAULT_REMOTE_AUDIO_GAIN = 10;
+export type RemoteAudioTrackLike = {
+    kind?: string;
+    _setVolume?: (volume: number) => void;
+};
+export declare function applyRemoteAudioPlaybackGain(stream: MediaStreamLike | null | undefined, gain?: number): void;
+export declare function applyRemoteAudioPlaybackGainToTrack(track: RemoteAudioTrackLike | null | undefined, gain?: number): void;
+//# sourceMappingURL=remote-audio-gain.d.ts.map

package/dist/voice/remote-audio-gain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-audio-gain.d.ts","sourceRoot":"","sources":["../../src/voice/remote-audio-gain.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,wFAAwF;AACxF,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAE5C,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC,CAAC;AAEF,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,eAAe,GAAG,IAAI,GAAG,SAAS,EAC1C,IAAI,GAAE,MAAkC,GACvC,IAAI,CAQN;AAED,wBAAgB,mCAAmC,CACjD,KAAK,EAAE,oBAAoB,GAAG,IAAI,GAAG,SAAS,EAC9C,IAAI,GAAE,MAAkC,GACvC,IAAI,CAIN"}

package/dist/voice/remote-audio-gain.js

@@ -0,0 +1,19 @@
+/** react-native-webrtc `_setVolume` range; default 1.0 is quiet vs media-player TTS. */
+export const DEFAULT_REMOTE_AUDIO_GAIN = 10;
+export function applyRemoteAudioPlaybackGain(stream, gain = DEFAULT_REMOTE_AUDIO_GAIN) {
+    if (!stream?.getAudioTracks)
+        return;
+    const clamped = Math.max(0, Math.min(10, gain));
+    for (const track of stream.getAudioTracks()) {
+        if ((track.kind === 'audio' || track.kind == null) && track._setVolume) {
+            track._setVolume(clamped);
+        }
+    }
+}
+export function applyRemoteAudioPlaybackGainToTrack(track, gain = DEFAULT_REMOTE_AUDIO_GAIN) {
+    if (!track || (track.kind !== 'audio' && track.kind != null))
+        return;
+    if (!track._setVolume)
+        return;
+    track._setVolume(Math.max(0, Math.min(10, gain)));
+}

package/dist/voice/start-voice-session.d.ts

@@ -0,0 +1,13 @@
+import type { HttpFetch } from '../ports/HttpPort';
+import type { WebRTCPort } from '../ports/WebRTCPort';
+import type { StartVoiceSessionOptions, VoiceSession } from './types';
+export type StartVoiceSessionDeps = {
+    baseUrl: string;
+    webrtc: WebRTCPort;
+    fetchFn?: HttpFetch;
+};
+/**
+ * Platform-agnostic WebRTC voice session (browser or React Native via {@link WebRTCPort}).
+ */
+export declare function startVoiceSessionWithPort(deps: StartVoiceSessionDeps, options: StartVoiceSessionOptions): Promise<VoiceSession>;
+//# sourceMappingURL=start-voice-session.d.ts.map

package/dist/voice/start-voice-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start-voice-session.d.ts","sourceRoot":"","sources":["../../src/voice/start-voice-session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAuC,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAU3F,OAAO,KAAK,EAAE,wBAAwB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AActE,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,CAAC,EAAE,SAAS,CAAC;CACrB,CAAC;AA4BF;;GAEG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,qBAAqB,EAC3B,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,YAAY,CAAC,CAiTvB"}

package/dist/voice/start-voice-session.js

@@ -0,0 +1,303 @@
+import { createAppChannelDispatcher } from './app-channel-dispatcher';
+import { appendVoiceModeToSignalingUrl, createVoiceSession, } from './create-voice-session';
+import { createOutputAudioLevelMeter, } from './output-audio-level';
+import { applyRemoteAudioPlaybackGain, applyRemoteAudioPlaybackGainToTrack, DEFAULT_REMOTE_AUDIO_GAIN, } from './remote-audio-gain';
+import { buildUserInputPayload } from './voice-user-input';
+const ICE_GATHERING_TIMEOUT_MS = 5000;
+async function endVoiceSession(baseUrl, fetchFn, params) {
+    try {
+        await fetchFn(`${baseUrl.replace(/\/+$/, '')}/api/voice/session`, {
+            method: 'DELETE',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                apiKey: params.apiKey,
+                apiSecret: params.apiSecret,
+                voiceSessionId: params.voiceSessionId,
+                endReason: params.endReason,
+            }),
+        });
+    }
+    catch {
+        /* best-effort */
+    }
+}
+/**
+ * Platform-agnostic WebRTC voice session (browser or React Native via {@link WebRTCPort}).
+ */
+export async function startVoiceSessionWithPort(deps, options) {
+    const fetchFn = deps.fetchFn ?? globalThis.fetch;
+    const baseUrl = (options.baseUrl ?? deps.baseUrl ?? '').replace(/\/+$/, '');
+    if (!baseUrl) {
+        throw new Error('startVoiceSession: API host is empty. Call setApiHosts() or pass baseUrl.');
+    }
+    const sessionData = await createVoiceSession(baseUrl, {
+        apiKey: options.apiKey,
+        apiSecret: options.apiSecret,
+        pseudoId: options.pseudoId,
+        externalId: options.externalId,
+        aitId: options.aitId,
+        walletAddress: options.walletAddress,
+        aitToken: options.aitToken,
+        voiceMode: options.voiceMode,
+        metadata: options.metadata,
+    }, fetchFn);
+    const voiceSessionId = sessionData.voiceSessionId;
+    const resolvedMode = sessionData.mode === 'realtime' || options.voiceMode === 'realtime'
+        ? 'realtime'
+        : 'cascade';
+    const signalingUrl = appendVoiceModeToSignalingUrl(sessionData.signalingUrl, resolvedMode);
+    const remoteAudioGain = options.remoteAudioGain ?? DEFAULT_REMOTE_AUDIO_GAIN;
+    const micStream = await deps.webrtc.getUserMedia({ audio: true });
+    let micMuted = options.startWithMicMuted === true;
+    let channelOpened = false;
+    const setMicTracksEnabled = (enabled) => {
+        for (const track of micStream.getAudioTracks()) {
+            track.enabled = enabled;
+        }
+    };
+    if (micMuted) {
+        setMicTracksEnabled(false);
+    }
+    const pc = deps.webrtc.createPeerConnection({
+        iceServers: sessionData.iceServers,
+    });
+    let errorFired = false;
+    const reportError = (err) => {
+        if (errorFired)
+            return;
+        errorFired = true;
+        options.onError?.(err);
+    };
+    let closeNotified = false;
+    const notifyClose = (reason) => {
+        if (closeNotified)
+            return;
+        closeNotified = true;
+        options.onClose?.(reason);
+    };
+    let activeAppChannel = pc.createDataChannel('app');
+    const dispatcher = createAppChannelDispatcher(options, reportError);
+    dispatcher.state.micMuted = micMuted;
+    const handleAppChannelOpen = () => {
+        if (channelOpened)
+            return;
+        channelOpened = true;
+        if (micMuted) {
+            try {
+                activeAppChannel.send(JSON.stringify({ type: 'mute', muted: true }));
+            }
+            catch {
+                /* noop */
+            }
+        }
+        options.onOpen?.();
+    };
+    const wireAppChannel = (channel) => {
+        activeAppChannel = channel;
+        channel.onopen = handleAppChannelOpen;
+        channel.onclose = () => {
+            notifyClose('datachannel_closed');
+        };
+        channel.onmessage = (event) => {
+            let payload;
+            try {
+                payload = JSON.parse(event.data);
+            }
+            catch {
+                return;
+            }
+            const ts = typeof payload.ts === 'number' ? payload.ts : Date.now();
+            dispatcher.handleMessage(payload, ts);
+        };
+        if (channel.readyState === 'open') {
+            handleAppChannelOpen();
+        }
+    };
+    wireAppChannel(activeAppChannel);
+    pc.ondatachannel = (event) => {
+        if (event.channel) {
+            wireAppChannel(event.channel);
+        }
+    };
+    pc.onconnectionstatechange = () => {
+        if (pc.connectionState === 'connected' && activeAppChannel.readyState === 'open') {
+            handleAppChannelOpen();
+        }
+        else if (pc.connectionState === 'failed') {
+            reportError(new Error('PeerConnection failed'));
+        }
+        else if (pc.connectionState === 'closed') {
+            notifyClose('peerconnection_closed');
+        }
+    };
+    pc.oniceconnectionstatechange = () => {
+        if (pc.iceConnectionState === 'failed') {
+            reportError(new Error('ICE connection failed (TURN/firewall?)'));
+        }
+    };
+    const remoteTracks = [];
+    let remoteStream = null;
+    let remoteMediaStream = null;
+    let outputMeter = null;
+    const attachOutputMeter = () => {
+        outputMeter?.dispose();
+        outputMeter = createOutputAudioLevelMeter({
+            remoteStream: remoteMediaStream,
+            getPeerConnection: () => {
+                const native = pc.__nativePc;
+                return native ?? null;
+            },
+        });
+    };
+    pc.ontrack = (event) => {
+        applyRemoteAudioPlaybackGainToTrack(event.track, remoteAudioGain);
+        const fromEvent = event.streams[0];
+        if (fromEvent) {
+            remoteStream = fromEvent;
+            remoteMediaStream = fromEvent;
+            applyRemoteAudioPlaybackGain(remoteStream, remoteAudioGain);
+            attachOutputMeter();
+            return;
+        }
+        remoteTracks.push(event.track);
+        remoteStream = {
+            getAudioTracks: () => remoteTracks.filter((t) => t.kind === 'audio'),
+        };
+        remoteMediaStream = null;
+        applyRemoteAudioPlaybackGain(remoteStream, remoteAudioGain);
+        attachOutputMeter();
+        if (activeAppChannel.readyState === 'open') {
+            handleAppChannelOpen();
+        }
+    };
+    for (const track of micStream.getAudioTracks()) {
+        pc.addTrack(track, micStream);
+    }
+    const applyMicMuted = (muted) => {
+        micMuted = muted;
+        dispatcher.state.micMuted = muted;
+        setMicTracksEnabled(!muted);
+        if (channelOpened && activeAppChannel.readyState === 'open') {
+            try {
+                activeAppChannel.send(JSON.stringify({ type: 'mute', muted }));
+            }
+            catch {
+                /* noop */
+            }
+        }
+    };
+    const offer = await pc.createOffer();
+    await pc.setLocalDescription(offer);
+    await deps.webrtc.waitForIceGathering(pc, ICE_GATHERING_TIMEOUT_MS);
+    const local = pc.getLocalDescription();
+    if (!local?.sdp) {
+        throw new Error('Local SDP description missing after ICE gathering.');
+    }
+    const answerRes = await fetchFn(signalingUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            voiceSessionId,
+            sdp: local.sdp,
+            type: local.type ?? 'offer',
+        }),
+    });
+    if (!answerRes.ok) {
+        const errBody = await answerRes.text().catch(() => '');
+        throw new Error(`Signaling POST failed: ${answerRes.status} ${errBody}`);
+    }
+    const answer = (await answerRes.json());
+    if (!answer.sdp || (answer.type !== 'answer' && answer.type !== 'pranswer')) {
+        throw new Error(`Signaling returned malformed answer: ${JSON.stringify(answer).slice(0, 200)}`);
+    }
+    await pc.setRemoteDescription({ sdp: answer.sdp, type: answer.type });
+    const channelWatch = setInterval(() => {
+        if (activeAppChannel.readyState === 'open') {
+            clearInterval(channelWatch);
+            handleAppChannelOpen();
+        }
+    }, 50);
+    setTimeout(() => clearInterval(channelWatch), 15000);
+    let stopped = false;
+    const sendAppMessage = (payload) => {
+        if (!channelOpened || activeAppChannel.readyState !== 'open') {
+            throw new Error('Voice app channel is not open');
+        }
+        activeAppChannel.send(JSON.stringify(payload));
+    };
+    const sendVoiceUserInput = (input) => {
+        const interruptFirst = input.interruptFirst !== false;
+        if (interruptFirst) {
+            try {
+                sendAppMessage({ type: 'interrupt' });
+            }
+            catch {
+                /* channel may not be ready yet */
+            }
+        }
+        sendAppMessage(buildUserInputPayload(input));
+    };
+    const stop = async (reason = 'client_stop') => {
+        if (stopped)
+            return;
+        stopped = true;
+        outputMeter?.dispose();
+        outputMeter = null;
+        await endVoiceSession(baseUrl, fetchFn, {
+            apiKey: options.apiKey,
+            apiSecret: options.apiSecret,
+            voiceSessionId,
+            endReason: reason,
+        });
+        try {
+            activeAppChannel.close();
+        }
+        catch {
+            /* noop */
+        }
+        for (const track of micStream.getAudioTracks()) {
+            try {
+                track.stop();
+            }
+            catch {
+                /* noop */
+            }
+        }
+        if (remoteStream?.getAudioTracks) {
+            for (const track of remoteStream.getAudioTracks()) {
+                try {
+                    track.stop();
+                }
+                catch {
+                    /* noop */
+                }
+            }
+        }
+        remoteStream = null;
+        try {
+            pc.close();
+        }
+        catch {
+            /* noop */
+        }
+    };
+    return {
+        id: voiceSessionId,
+        getRemoteAudioStream: () => remoteStream,
+        getOutputAudioLevel: () => outputMeter?.getLevel() ?? 0,
+        isAppChannelOpen: () => channelOpened && activeAppChannel.readyState === 'open',
+        sendVoiceUserInput,
+        muteMic: (muted) => applyMicMuted(muted),
+        interrupt: () => {
+            if (channelOpened && activeAppChannel.readyState === 'open') {
+                try {
+                    activeAppChannel.send(JSON.stringify({ type: 'interrupt' }));
+                }
+                catch {
+                    /* noop */
+                }
+            }
+        },
+        stop,
+    };
+}

package/dist/voice/transcript.d.ts

@@ -0,0 +1,10 @@
+/** Loose compare key — ignores case/punctuation; keeps CJK and other letters. */
+export declare function normalizeTranscriptKey(text: string): string;
+/**
+ * Merge streaming transcript updates. Pipecat RTVI usually sends cumulative
+ * snapshots (each event is the full hypothesis so far).
+ */
+export declare function mergeStreamingTranscript(current: string, incoming: string): string;
+/** @deprecated Use mergeStreamingTranscript */
+export declare function appendTranscriptSegment(current: string, chunk: string): string;
+//# sourceMappingURL=transcript.d.ts.map

package/dist/voice/transcript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcript.d.ts","sourceRoot":"","sources":["../../src/voice/transcript.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAK3D;AAYD;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAgBlF;AAED,+CAA+C;AAC/C,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAE9E"}

package/dist/voice/transcript.js

@@ -0,0 +1,50 @@
+/** Loose compare key — ignores case/punctuation; keeps CJK and other letters. */
+export function normalizeTranscriptKey(text) {
+    return text
+        .normalize('NFKC')
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}]/gu, '');
+}
+function joinTranscriptSegments(base, piece) {
+    const last = base.slice(-1);
+    const first = piece[0] ?? '';
+    const isCjk = (ch) => /[\u3000-\u9fff\uf900-\ufaff]/.test(ch);
+    if (isCjk(last) && isCjk(first))
+        return `${base}${piece}`;
+    if (/[a-z0-9]/i.test(last) && /[a-z0-9]/i.test(first))
+        return `${base} ${piece}`;
+    if (/\s$/.test(base) || /^\s/.test(piece))
+        return `${base}${piece}`;
+    return `${base}${piece}`;
+}
+/**
+ * Merge streaming transcript updates. Pipecat RTVI usually sends cumulative
+ * snapshots (each event is the full hypothesis so far).
+ */
+export function mergeStreamingTranscript(current, incoming) {
+    const piece = incoming.trim();
+    if (!piece)
+        return current.trim();
+    const base = current.trim();
+    if (!base)
+        return piece;
+    if (piece === base)
+        return base;
+    if (piece.startsWith(base))
+        return piece;
+    if (base.startsWith(piece))
+        return base;
+    const normBase = normalizeTranscriptKey(base);
+    const normPiece = normalizeTranscriptKey(piece);
+    if (normPiece && normBase && normPiece.startsWith(normBase))
+        return piece;
+    if (normPiece && normBase && normBase.startsWith(normPiece))
+        return base;
+    if (base.endsWith(piece))
+        return base;
+    return joinTranscriptSegments(base, piece);
+}
+/** @deprecated Use mergeStreamingTranscript */
+export function appendTranscriptSegment(current, chunk) {
+    return mergeStreamingTranscript(current, chunk);
+}

package/dist/voice/trigger-voice-greeting.d.ts

@@ -0,0 +1,14 @@
+import type { Message } from '../types/ait-api';
+import type { VoiceGreetingOptions, VoiceSession } from './types';
+export type TriggerVoiceGreetingParams = {
+    session: VoiceSession;
+    options: VoiceGreetingOptions;
+    /** Optional: append a local-only user bubble for hero/welcome UI. */
+    appendLocalUserMessage?: (message: Message) => void;
+};
+/**
+ * Berify-style auto-greet: inject synthetic user turn (+ optional product image)
+ * over the voice `app` data channel after session is active.
+ */
+export declare function triggerVoiceGreeting({ session, options, appendLocalUserMessage, }: TriggerVoiceGreetingParams): void;
+//# sourceMappingURL=trigger-voice-greeting.d.ts.map

package/dist/voice/trigger-voice-greeting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger-voice-greeting.d.ts","sourceRoot":"","sources":["../../src/voice/trigger-voice-greeting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAGlE,MAAM,MAAM,0BAA0B,GAAG;IACvC,OAAO,EAAE,YAAY,CAAC;IACtB,OAAO,EAAE,oBAAoB,CAAC;IAC9B,qEAAqE;IACrE,sBAAsB,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;CACrD,CAAC;AAEF;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,OAAO,EACP,OAAO,EACP,sBAAsB,GACvB,EAAE,0BAA0B,GAAG,IAAI,CA2BnC"}

package/dist/voice/trigger-voice-greeting.js

@@ -0,0 +1,28 @@
+/**
+ * Berify-style auto-greet: inject synthetic user turn (+ optional product image)
+ * over the voice `app` data channel after session is active.
+ */
+export function triggerVoiceGreeting({ session, options, appendLocalUserMessage, }) {
+    const text = options.text.trim();
+    if (!text && !options.attachments?.length) {
+        throw new Error('triggerVoiceGreeting: text or attachments required');
+    }
+    const clientMessageId = options.clientMessageId ?? `greeting_${Date.now()}`;
+    if (!options.skipUserMessage && appendLocalUserMessage) {
+        appendLocalUserMessage({
+            id: clientMessageId,
+            role: 'user',
+            content: text,
+            timestamp: new Date().toISOString(),
+            attachments: options.attachments,
+            metadata: { voiceRealtime: true, voiceSessionId: session.id },
+        });
+    }
+    const input = {
+        text: text || ' ',
+        attachments: options.attachments,
+        clientMessageId,
+        interruptFirst: options.interruptFirst ?? false,
+    };
+    session.sendVoiceUserInput(input);
+}