@bytexbyte/nxtlinq-ai-agent-react-native-development 0.2.0

package/dist/ports/createRNWebRTCPort.js

@@ -0,0 +1,235 @@
+import { VoiceNotSupportedError } from '@bytexbyte/nxtlinq-ai-agent-core-development';
+import { ensureRecordAudioPermission } from '../utils/ensureRecordAudioPermission';
+import { ensureIOSAudioSessionForVoiceCapture, getIOSVoiceCaptureGeneration, markIOSVoiceCaptureCompleted, } from '../utils/iosAudioSessionReady';
+import { activateIOSWebRTCAudioSession, deactivateIOSWebRTCAudioSession, } from '../utils/iosWebRTCAudioSession';
+const ICE_GATHERING_TIMEOUT_MS = 5000;
+function bindDataChannelEvent(channel, type, handler) {
+    if (!handler)
+        return;
+    if (channel.addEventListener) {
+        if (type === 'message') {
+            channel.addEventListener('message', (event) => {
+                handler({
+                    data: String(event?.data ?? ''),
+                });
+            });
+        }
+        else {
+            channel.addEventListener(type, () => {
+                handler();
+            });
+        }
+        return;
+    }
+    if (type === 'open') {
+        channel.onopen = handler;
+    }
+    else if (type === 'message') {
+        channel.onmessage = handler;
+    }
+    else {
+        channel.onclose = handler;
+    }
+}
+function wrapDataChannel(channel) {
+    let onopenHandler = null;
+    let onmessageHandler = null;
+    let oncloseHandler = null;
+    return {
+        get readyState() {
+            return channel.readyState;
+        },
+        get onopen() {
+            return onopenHandler;
+        },
+        set onopen(handler) {
+            onopenHandler = handler;
+            if (handler) {
+                bindDataChannelEvent(channel, 'open', handler);
+                if (channel.readyState === 'open') {
+                    queueMicrotask(() => handler());
+                }
+            }
+        },
+        get onmessage() {
+            return onmessageHandler;
+        },
+        set onmessage(handler) {
+            onmessageHandler = handler;
+            if (handler)
+                bindDataChannelEvent(channel, 'message', handler);
+        },
+        get onclose() {
+            return oncloseHandler;
+        },
+        set onclose(handler) {
+            oncloseHandler = handler;
+            if (handler)
+                bindDataChannelEvent(channel, 'close', handler);
+        },
+        send: (data) => channel.send(data),
+        close: () => channel.close(),
+    };
+}
+function wrapPeerConnection(pc) {
+    let connectionHandler = null;
+    let iceConnectionHandler = null;
+    let connectionBound = null;
+    let iceConnectionBound = null;
+    const wrapped = {
+        __nativePc: pc,
+        get connectionState() {
+            return pc.connectionState;
+        },
+        get iceConnectionState() {
+            return pc.iceConnectionState;
+        },
+        onconnectionstatechange: null,
+        oniceconnectionstatechange: null,
+        ontrack: null,
+        ondatachannel: null,
+        createDataChannel: (label) => wrapDataChannel(pc.createDataChannel(label)),
+        addTrack: (track, stream) => pc.addTrack(track, stream),
+        createOffer: () => pc.createOffer(),
+        setLocalDescription: (desc) => pc.setLocalDescription(desc),
+        setRemoteDescription: (desc) => pc.setRemoteDescription(desc),
+        getLocalDescription: () => {
+            const local = pc.localDescription;
+            return local ? { sdp: local.sdp, type: local.type } : null;
+        },
+        close: () => pc.close(),
+    };
+    Object.defineProperty(wrapped, 'onconnectionstatechange', {
+        get: () => connectionHandler,
+        set(handler) {
+            connectionHandler = handler;
+            if (connectionBound) {
+                pc.removeEventListener('connectionstatechange', connectionBound);
+                connectionBound = null;
+            }
+            if (handler) {
+                connectionBound = () => handler();
+                pc.addEventListener('connectionstatechange', connectionBound);
+            }
+        },
+        configurable: true,
+    });
+    Object.defineProperty(wrapped, 'oniceconnectionstatechange', {
+        get: () => iceConnectionHandler,
+        set(handler) {
+            iceConnectionHandler = handler;
+            if (iceConnectionBound) {
+                pc.removeEventListener('iceconnectionstatechange', iceConnectionBound);
+                iceConnectionBound = null;
+            }
+            if (handler) {
+                iceConnectionBound = () => handler();
+                pc.addEventListener('iceconnectionstatechange', iceConnectionBound);
+            }
+        },
+        configurable: true,
+    });
+    let trackHandler = null;
+    const trackListener = (event) => {
+        trackHandler?.({
+            streams: (event.streams ?? []),
+            track: event.track ?? { kind: 'audio' },
+        });
+    };
+    pc.addEventListener('track', trackListener);
+    Object.defineProperty(wrapped, 'ontrack', {
+        get: () => trackHandler,
+        set(handler) {
+            trackHandler = handler;
+        },
+        configurable: true,
+    });
+    let datachannelHandler = null;
+    const datachannelListener = (event) => {
+        if (!event.channel)
+            return;
+        datachannelHandler?.({ channel: wrapDataChannel(event.channel) });
+    };
+    pc.addEventListener('datachannel', datachannelListener);
+    Object.defineProperty(wrapped, 'ondatachannel', {
+        get: () => datachannelHandler,
+        set(handler) {
+            datachannelHandler = handler;
+        },
+        configurable: true,
+    });
+    return wrapped;
+}
+/**
+ * React Native WebRTC adapter — pass exports from `react-native-webrtc`.
+ *
+ * @example
+ * import { RTCPeerConnection, mediaDevices } from 'react-native-webrtc';
+ * const webrtc = createRNWebRTCPort({ RTCPeerConnection, mediaDevices });
+ */
+export function createRNWebRTCPort(module) {
+    if (!module?.RTCPeerConnection || !module?.mediaDevices?.getUserMedia) {
+        throw new VoiceNotSupportedError('react-native-webrtc is required — install and link the native module.');
+    }
+    return {
+        isSupported: () => Boolean(module.RTCPeerConnection && module.mediaDevices?.getUserMedia),
+        getUserMedia: async (constraints) => {
+            if (!constraints.audio) {
+                return (await module.mediaDevices.getUserMedia(constraints));
+            }
+            const generation = getIOSVoiceCaptureGeneration();
+            const maxAttempts = 3;
+            for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+                await ensureIOSAudioSessionForVoiceCapture();
+                await ensureRecordAudioPermission();
+                activateIOSWebRTCAudioSession();
+                const stream = (await module.mediaDevices.getUserMedia(constraints));
+                const tracks = stream.getAudioTracks();
+                const hasLiveTrack = tracks.some((track) => track.readyState === 'live');
+                if (hasLiveTrack || tracks.length === 0) {
+                    markIOSVoiceCaptureCompleted();
+                    return stream;
+                }
+                console.warn(`[nxtlinq] iOS mic track not live (gen=${generation}, attempt=${attempt}/${maxAttempts}), retrying…`);
+                for (const track of tracks) {
+                    try {
+                        track.stop();
+                    }
+                    catch {
+                        /* noop */
+                    }
+                }
+                deactivateIOSWebRTCAudioSession();
+                await new Promise((resolve) => {
+                    setTimeout(resolve, 350 * attempt);
+                });
+            }
+            throw new Error('Failed to acquire live iOS microphone track after retries');
+        },
+        createPeerConnection: (config) => wrapPeerConnection(new module.RTCPeerConnection(config)),
+        waitForIceGathering: async (pc, timeoutMs = ICE_GATHERING_TIMEOUT_MS) => {
+            const native = pc.__nativePc;
+            if (native.iceGatheringState === 'complete')
+                return;
+            await new Promise((resolve) => {
+                let done = false;
+                const finish = () => {
+                    if (done)
+                        return;
+                    done = true;
+                    native.removeEventListener('icegatheringstatechange', check);
+                    clearTimeout(timer);
+                    resolve();
+                };
+                const check = () => {
+                    if (native.iceGatheringState === 'complete')
+                        finish();
+                };
+                native.addEventListener('icegatheringstatechange', check);
+                if (native.iceGatheringState === 'complete')
+                    finish();
+                const timer = setTimeout(finish, timeoutMs);
+            });
+        },
+    };
+}

package/dist/utils/ensureRecordAudioPermission.d.ts

@@ -0,0 +1,7 @@
+export declare class MicrophonePermissionDeniedError extends Error {
+    readonly name = "MicrophonePermissionDeniedError";
+    constructor(message?: string);
+}
+/** Android requires runtime RECORD_AUDIO before `getUserMedia({ audio: true })`. */
+export declare function ensureRecordAudioPermission(): Promise<void>;
+//# sourceMappingURL=ensureRecordAudioPermission.d.ts.map

package/dist/utils/ensureRecordAudioPermission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensureRecordAudioPermission.d.ts","sourceRoot":"","sources":["../../src/utils/ensureRecordAudioPermission.ts"],"names":[],"mappings":"AAEA,qBAAa,+BAAgC,SAAQ,KAAK;IACxD,QAAQ,CAAC,IAAI,qCAAqC;gBAEtC,OAAO,SAAiC;CAGrD;AAED,oFAAoF;AACpF,wBAAsB,2BAA2B,IAAI,OAAO,CAAC,IAAI,CAAC,CAgBjE"}

package/dist/utils/ensureRecordAudioPermission.js

@@ -0,0 +1,24 @@
+import { Platform, PermissionsAndroid } from 'react-native';
+export class MicrophonePermissionDeniedError extends Error {
+    constructor(message = 'Microphone permission denied') {
+        super(message);
+        this.name = 'MicrophonePermissionDeniedError';
+    }
+}
+/** Android requires runtime RECORD_AUDIO before `getUserMedia({ audio: true })`. */
+export async function ensureRecordAudioPermission() {
+    if (Platform.OS !== 'android')
+        return;
+    const permission = PermissionsAndroid.PERMISSIONS.RECORD_AUDIO;
+    if (await PermissionsAndroid.check(permission))
+        return;
+    const result = await PermissionsAndroid.request(permission, {
+        title: 'Microphone',
+        message: 'Allow microphone access for voice chat.',
+        buttonPositive: 'OK',
+        buttonNegative: 'Cancel',
+    });
+    if (result !== PermissionsAndroid.RESULTS.GRANTED) {
+        throw new MicrophonePermissionDeniedError();
+    }
+}

package/dist/utils/fetchUriAsDataUri.d.ts

@@ -0,0 +1,11 @@
+import type { Attachment } from '@bytexbyte/nxtlinq-ai-agent-core-development';
+/**
+ * Prefer HTTPS URL as-is (avoids huge base64 over SCTP). Local `file://` URIs are
+ * still read and encoded as data URIs.
+ */
+export declare function uriToVoiceImageAttachment(uri: string, name?: string): Promise<Attachment>;
+/**
+ * Build an image {@link Attachment} from a remote URL or local file URI (RN / browser).
+ */
+export declare function fetchUriAsDataUriAttachment(uri: string, name?: string): Promise<Attachment>;
+//# sourceMappingURL=fetchUriAsDataUri.d.ts.map

package/dist/utils/fetchUriAsDataUri.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchUriAsDataUri.d.ts","sourceRoot":"","sources":["../../src/utils/fetchUriAsDataUri.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8CAA8C,CAAC;AAyG/E;;;GAGG;AACH,wBAAsB,yBAAyB,CAC7C,GAAG,EAAE,MAAM,EACX,IAAI,SAAc,GACjB,OAAO,CAAC,UAAU,CAAC,CAsBrB;AAED;;GAEG;AACH,wBAAsB,2BAA2B,CAC/C,GAAG,EAAE,MAAM,EACX,IAAI,SAAc,GACjB,OAAO,CAAC,UAAU,CAAC,CAuBrB"}

package/dist/utils/fetchUriAsDataUri.js

@@ -0,0 +1,143 @@
+function guessMime(uri) {
+    const lower = uri.split('?')[0]?.toLowerCase() ?? '';
+    if (lower.endsWith('.png'))
+        return 'image/png';
+    if (lower.endsWith('.webp'))
+        return 'image/webp';
+    if (lower.endsWith('.gif'))
+        return 'image/gif';
+    return 'image/jpeg';
+}
+function normalizeMime(header, fallback) {
+    const raw = header?.split(';')[0]?.trim().toLowerCase();
+    if (!raw || !raw.startsWith('image/'))
+        return fallback;
+    return raw === 'image/jpg' ? 'image/jpeg' : raw;
+}
+function bytesToBase64(bytes) {
+    if (typeof globalThis.Buffer !== 'undefined') {
+        return globalThis.Buffer.from(bytes).toString('base64');
+    }
+    let binary = '';
+    const chunk = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunk) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+    }
+    if (typeof globalThis.btoa !== 'function') {
+        throw new Error('No base64 encoder available in this runtime');
+    }
+    return globalThis.btoa(binary);
+}
+/** Read binary from fetch Response (RN Blob often lacks arrayBuffer()). */
+async function readResponseBytes(res, fallbackMime) {
+    const headerMime = normalizeMime(res.headers.get('content-type'), fallbackMime);
+    if (typeof res.arrayBuffer === 'function') {
+        const buffer = await res.arrayBuffer();
+        return { bytes: new Uint8Array(buffer), mimeType: headerMime };
+    }
+    const blob = await res.blob();
+    if (typeof blob.arrayBuffer === 'function') {
+        const buffer = await blob.arrayBuffer();
+        return {
+            bytes: new Uint8Array(buffer),
+            mimeType: normalizeMime(blob.type, headerMime),
+        };
+    }
+    throw new Error('fetch response cannot be read as binary in this runtime');
+}
+/** XHR fallback for RN runtimes where fetch().arrayBuffer() is unavailable. */
+function xhrGetBytes(uri) {
+    return new Promise((resolve, reject) => {
+        const xhr = new XMLHttpRequest();
+        xhr.onload = () => {
+            if (xhr.status < 200 || xhr.status >= 300) {
+                reject(new Error(`Failed to fetch image: ${xhr.status}`));
+                return;
+            }
+            const body = xhr.response;
+            if (!(body instanceof ArrayBuffer)) {
+                reject(new Error('XHR did not return ArrayBuffer'));
+                return;
+            }
+            resolve({
+                bytes: new Uint8Array(body),
+                mimeType: normalizeMime(xhr.getResponseHeader('Content-Type'), guessMime(uri)),
+            });
+        };
+        xhr.onerror = () => reject(new Error('Failed to fetch image'));
+        xhr.responseType = 'arraybuffer';
+        xhr.open('GET', uri);
+        xhr.send();
+    });
+}
+async function fetchUriBytes(uri) {
+    const fallbackMime = guessMime(uri);
+    try {
+        const res = await fetch(uri);
+        if (!res.ok) {
+            throw new Error(`Failed to fetch image: ${res.status}`);
+        }
+        return await readResponseBytes(res, fallbackMime);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes('arrayBuffer') ||
+            message.includes('binary in this runtime')) {
+            return xhrGetBytes(uri);
+        }
+        throw err;
+    }
+}
+/**
+ * Prefer HTTPS URL as-is (avoids huge base64 over SCTP). Local `file://` URIs are
+ * still read and encoded as data URIs.
+ */
+export async function uriToVoiceImageAttachment(uri, name = 'image.jpg') {
+    const trimmed = uri.trim();
+    if (!trimmed) {
+        throw new Error('uriToVoiceImageAttachment: uri is empty');
+    }
+    if (trimmed.startsWith('data:')) {
+        return {
+            type: 'image',
+            url: trimmed,
+            name,
+            mimeType: trimmed.slice(5, trimmed.indexOf(';')) || guessMime(name),
+        };
+    }
+    if (/^https?:\/\//i.test(trimmed)) {
+        return {
+            type: 'image',
+            url: trimmed,
+            name,
+            mimeType: guessMime(trimmed),
+        };
+    }
+    return fetchUriAsDataUriAttachment(trimmed, name);
+}
+/**
+ * Build an image {@link Attachment} from a remote URL or local file URI (RN / browser).
+ */
+export async function fetchUriAsDataUriAttachment(uri, name = 'image.jpg') {
+    const trimmed = uri.trim();
+    if (!trimmed) {
+        throw new Error('fetchUriAsDataUriAttachment: uri is empty');
+    }
+    if (trimmed.startsWith('data:')) {
+        return {
+            type: 'image',
+            url: trimmed,
+            name,
+            mimeType: trimmed.slice(5, trimmed.indexOf(';')) || guessMime(name),
+        };
+    }
+    const { bytes, mimeType } = await fetchUriBytes(trimmed);
+    const base64 = bytesToBase64(bytes);
+    return {
+        type: 'image',
+        url: `data:${mimeType};base64,${base64}`,
+        name,
+        mimeType,
+        size: bytes.length,
+    };
+}

package/dist/utils/iosAudioSessionReady.d.ts

@@ -0,0 +1,27 @@
+/** Called by {@link AudioSessionWaker} when silent.mp3 starts (react-native-video). */
+export declare function markIOSAudioSessionReady(): void;
+/**
+ * Register a handler that replays silent audio (mounted {@link AudioSessionWaker}).
+ * Must NOT unmount the video view — react-native-video deactivates AVAudioSession on unregister.
+ */
+export declare function setIOSAudioSessionPrewarmHandler(handler: (() => void) | null): void;
+/** Call after `getUserMedia({ audio: true })` succeeds so reconnect path is used. */
+export declare function markIOSVoiceCaptureCompleted(): void;
+/** Nudge silent playback after WebRTC releases the mic (text mode / session stop). */
+export declare function notifyIOSVoiceSessionEnded(): void;
+/**
+ * On iOS, WebRTC mic + speaker need AVAudioSession active (via react-native-video).
+ * Waits until {@link markIOSAudioSessionReady} or timeout.
+ */
+export declare function waitForIOSAudioSessionReady(timeoutMs?: number): Promise<void>;
+/**
+ * Before voice capture on iOS.
+ * - Cold start: wait for waker, then sync WebRTC audio session.
+ * - Reconnect: deactivate → nudge waker → activate WebRTC (required after ~4+ cycles on iOS).
+ */
+export declare function ensureIOSAudioSessionForVoiceCapture(timeoutMs?: number): Promise<void>;
+/** Allow WebRTC / AVAudioSession to release the mic before the next getUserMedia. */
+export declare function waitForIOSVoiceCaptureRelease(): Promise<void>;
+/** Current capture generation — useful for logging flaky reconnect attempts. */
+export declare function getIOSVoiceCaptureGeneration(): number;
+//# sourceMappingURL=iosAudioSessionReady.d.ts.map

package/dist/utils/iosAudioSessionReady.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iosAudioSessionReady.d.ts","sourceRoot":"","sources":["../../src/utils/iosAudioSessionReady.ts"],"names":[],"mappings":"AAeA,uFAAuF;AACvF,wBAAgB,wBAAwB,IAAI,IAAI,CAK/C;AAED;;;GAGG;AACH,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI,CAEnF;AAED,qFAAqF;AACrF,wBAAgB,4BAA4B,IAAI,IAAI,CAGnD;AAED,sFAAsF;AACtF,wBAAgB,0BAA0B,IAAI,IAAI,CAGjD;AAED;;;GAGG;AACH,wBAAsB,2BAA2B,CAAC,SAAS,SAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAiBjF;AAYD;;;;GAIG;AACH,wBAAsB,oCAAoC,CACxD,SAAS,SAAO,GACf,OAAO,CAAC,IAAI,CAAC,CASf;AAED,qFAAqF;AACrF,wBAAsB,6BAA6B,IAAI,OAAO,CAAC,IAAI,CAAC,CAKnE;AAED,gFAAgF;AAChF,wBAAgB,4BAA4B,IAAI,MAAM,CAErD"}

package/dist/utils/iosAudioSessionReady.js

@@ -0,0 +1,93 @@
+import { Platform } from 'react-native';
+import { activateIOSWebRTCAudioSession, deactivateIOSWebRTCAudioSession, } from './iosWebRTCAudioSession';
+let sessionReady = Platform.OS !== 'ios';
+const pending = [];
+let prewarmHandler = null;
+let hasCompletedVoiceCapture = false;
+let voiceCaptureGeneration = 0;
+const RECONNECT_SETTLE_MS = 550;
+const POST_STOP_SETTLE_MS = 550;
+/** Called by {@link AudioSessionWaker} when silent.mp3 starts (react-native-video). */
+export function markIOSAudioSessionReady() {
+    if (sessionReady)
+        return;
+    sessionReady = true;
+    for (const resolve of pending)
+        resolve();
+    pending.length = 0;
+}
+/**
+ * Register a handler that replays silent audio (mounted {@link AudioSessionWaker}).
+ * Must NOT unmount the video view — react-native-video deactivates AVAudioSession on unregister.
+ */
+export function setIOSAudioSessionPrewarmHandler(handler) {
+    prewarmHandler = handler;
+}
+/** Call after `getUserMedia({ audio: true })` succeeds so reconnect path is used. */
+export function markIOSVoiceCaptureCompleted() {
+    hasCompletedVoiceCapture = true;
+    voiceCaptureGeneration += 1;
+}
+/** Nudge silent playback after WebRTC releases the mic (text mode / session stop). */
+export function notifyIOSVoiceSessionEnded() {
+    if (Platform.OS !== 'ios')
+        return;
+    prewarmHandler?.();
+}
+/**
+ * On iOS, WebRTC mic + speaker need AVAudioSession active (via react-native-video).
+ * Waits until {@link markIOSAudioSessionReady} or timeout.
+ */
+export async function waitForIOSAudioSessionReady(timeoutMs = 5000) {
+    if (sessionReady)
+        return;
+    await Promise.race([
+        new Promise((resolve) => {
+            pending.push(resolve);
+        }),
+        new Promise((resolve) => {
+            setTimeout(() => {
+                if (!sessionReady) {
+                    console.warn('[nxtlinq] iOS AVAudioSession was not activated in time; pass iosSilentAudioSource and react-native-video');
+                }
+                resolve();
+            }, timeoutMs);
+        }),
+    ]);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function nudgeAndSettle() {
+    notifyIOSVoiceSessionEnded();
+    await sleep(RECONNECT_SETTLE_MS);
+    activateIOSWebRTCAudioSession();
+}
+/**
+ * Before voice capture on iOS.
+ * - Cold start: wait for waker, then sync WebRTC audio session.
+ * - Reconnect: deactivate → nudge waker → activate WebRTC (required after ~4+ cycles on iOS).
+ */
+export async function ensureIOSAudioSessionForVoiceCapture(timeoutMs = 5000) {
+    if (Platform.OS !== 'ios')
+        return;
+    if (!hasCompletedVoiceCapture) {
+        await waitForIOSAudioSessionReady(timeoutMs);
+        activateIOSWebRTCAudioSession();
+        return;
+    }
+    deactivateIOSWebRTCAudioSession();
+    await nudgeAndSettle();
+}
+/** Allow WebRTC / AVAudioSession to release the mic before the next getUserMedia. */
+export async function waitForIOSVoiceCaptureRelease() {
+    if (Platform.OS !== 'ios')
+        return;
+    deactivateIOSWebRTCAudioSession();
+    notifyIOSVoiceSessionEnded();
+    await sleep(POST_STOP_SETTLE_MS);
+}
+/** Current capture generation — useful for logging flaky reconnect attempts. */
+export function getIOSVoiceCaptureGeneration() {
+    return voiceCaptureGeneration;
+}

package/dist/utils/iosWebRTCAudioSession.d.ts

@@ -0,0 +1,5 @@
+/** Tell WebRTC the AVAudioSession is active (after react-native-video waker). */
+export declare function activateIOSWebRTCAudioSession(): void;
+/** Release WebRTC audio session lock after voice stop (before next getUserMedia). */
+export declare function deactivateIOSWebRTCAudioSession(): void;
+//# sourceMappingURL=iosWebRTCAudioSession.d.ts.map

package/dist/utils/iosWebRTCAudioSession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iosWebRTCAudioSession.d.ts","sourceRoot":"","sources":["../../src/utils/iosWebRTCAudioSession.ts"],"names":[],"mappings":"AAsBA,iFAAiF;AACjF,wBAAgB,6BAA6B,IAAI,IAAI,CAMpD;AAED,qFAAqF;AACrF,wBAAgB,+BAA+B,IAAI,IAAI,CAMtD"}

package/dist/utils/iosWebRTCAudioSession.js

@@ -0,0 +1,35 @@
+import { Platform } from 'react-native';
+let rtcAudioSession;
+function getRTCAudioSession() {
+    if (Platform.OS !== 'ios')
+        return null;
+    if (rtcAudioSession !== undefined)
+        return rtcAudioSession;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const mod = require('react-native-webrtc');
+        rtcAudioSession = mod.RTCAudioSession ?? null;
+    }
+    catch {
+        rtcAudioSession = null;
+    }
+    return rtcAudioSession;
+}
+/** Tell WebRTC the AVAudioSession is active (after react-native-video waker). */
+export function activateIOSWebRTCAudioSession() {
+    try {
+        getRTCAudioSession()?.audioSessionDidActivate();
+    }
+    catch (err) {
+        console.warn('[nxtlinq] RTCAudioSession.audioSessionDidActivate failed:', err);
+    }
+}
+/** Release WebRTC audio session lock after voice stop (before next getUserMedia). */
+export function deactivateIOSWebRTCAudioSession() {
+    try {
+        getRTCAudioSession()?.audioSessionDidDeactivate();
+    }
+    catch (err) {
+        console.warn('[nxtlinq] RTCAudioSession.audioSessionDidDeactivate failed:', err);
+    }
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@bytexbyte/nxtlinq-ai-agent-react-native-development",
+  "version": "0.2.0",
+  "description": "React Native SDK for nxtlinq AI Agent — custom UI hooks and platform ports",
+  "main": "dist/index.js",
+  "react-native": "src/index.ts",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "yarn build"
+  },
+  "keywords": [
+    "nxtlinq",
+    "ai-agent",
+    "react-native",
+    "sdk"
+  ],
+  "author": "ByteXByte",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://dev.azure.com/nxtlinqLLC/nxtlinq/_git/nxtlinq-AI-Agent-SDK",
+    "directory": "packages/ai-agent-react-native"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "sideEffects": false,
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-native": ">=0.72.0"
+  },
+  "peerDependenciesMeta": {
+    "@react-native-async-storage/async-storage": {
+      "optional": true
+    },
+    "react-native-webrtc": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@bytexbyte/nxtlinq-ai-agent-core-development": "^0.2.0"
+  },
+  "devDependencies": {
+    "@bytexbyte/nxtlinq-ai-agent-core-development": "workspace:^",
+    "@types/react": "^18.2.64",
+    "react": "^18.2.0",
+    "typescript": "^5.4.2"
+  }
+}