@vanira/sdk-react-native 0.0.2

package/src/__tests__/adapters.test.ts

@@ -0,0 +1,475 @@
+/**
+ * Vanira SDK — Cross-platform adapter unit tests
+ *
+ * Tests cover:
+ *   1. BrowserPeerAdapter — wraps RTCPeerConnection creation
+ *   2. BrowserDataChannelAdapter — normalises browser message formats
+ *   3. RNDataChannelAdapter — handles RN string-only messages
+ *   4. BrowserMediaAdapter — wraps getUserMedia
+ *   5. BrowserAudioAdapter — wraps HTMLAudioElement
+ *   6. Runtime capabilities — correct flags per runtime
+ *   7. WebRTCClient — ICE server propagation, runtime injection
+ *   8. DataChannel protocol — JSON parsing, client_tool_call ack
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+
+// ─── Helpers: minimal browser global mocks ────────────────────────────────────
+
+function makeMockRTCPeerConnection() {
+    return {
+        addTrack: vi.fn(),
+        createDataChannel: vi.fn(() => makeMockRTCDataChannel()),
+        createOffer: vi.fn(() => Promise.resolve({ type: 'offer', sdp: 'mock-sdp' })),
+        setLocalDescription: vi.fn(() => Promise.resolve()),
+        setRemoteDescription: vi.fn(() => Promise.resolve()),
+        getSenders: vi.fn(() => []),
+        close: vi.fn(),
+        iceGatheringState: 'complete',
+        connectionState: 'new',
+        iceConnectionState: 'new',
+        localDescription: { type: 'offer', sdp: 'mock-sdp' },
+        ontrack: null,
+        onconnectionstatechange: null,
+        oniceconnectionstatechange: null,
+        addEventListener: vi.fn(),
+        removeEventListener: vi.fn(),
+    };
+}
+
+function makeMockRTCDataChannel() {
+    return {
+        send: vi.fn(),
+        close: vi.fn(),
+        readyState: 'open' as RTCDataChannelState,
+        onopen: null as (() => void) | null,
+        onmessage: null as ((e: MessageEvent) => void) | null,
+        onerror: null as ((e: Event) => void) | null,
+    };
+}
+
+// ─── 1. BrowserPeerAdapter ────────────────────────────────────────────────────
+
+describe('BrowserPeerAdapter', () => {
+    it('creates an RTCPeerConnection with correct ICE server config', async () => {
+        const mockPc = makeMockRTCPeerConnection();
+        // BrowserPeerAdapter uses `new RTCPeerConnection()` which requires the global
+        // to be a constructor function
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        function MockRTC(this: any, config: unknown) {
+            Object.assign(this, mockPc);
+            (MockRTC as unknown as { lastConfig: unknown }).lastConfig = config;
+        }
+        (globalThis as unknown as Record<string, unknown>).RTCPeerConnection = MockRTC;
+
+        const { BrowserPeerAdapter } = await import('../adapters/browser/BrowserPeerAdapter');
+        const adapter = new BrowserPeerAdapter();
+        adapter.create({
+            iceServers: [{ urls: 'stun:stun.l.google.com:19302' }],
+            iceTransportPolicy: 'all',
+        });
+
+        expect((MockRTC as unknown as { lastConfig: unknown }).lastConfig).toEqual({
+            iceServers: [{ urls: 'stun:stun.l.google.com:19302' }],
+            iceTransportPolicy: 'all',
+        });
+    });
+});
+
+// ─── 2. BrowserDataChannelAdapter ────────────────────────────────────────────
+
+describe('BrowserDataChannelAdapter', () => {
+    it('forwards string messages directly', async () => {
+        const { BrowserDataChannelAdapter } = await import('../adapters/browser/BrowserDataChannelAdapter');
+        const channel = makeMockRTCDataChannel();
+        const onMessage = vi.fn();
+
+        const adapter = new BrowserDataChannelAdapter();
+        adapter.bind(channel as unknown as RTCDataChannel, {
+            onOpen: vi.fn(),
+            onMessage,
+            onError: vi.fn(),
+        });
+
+        const event = { data: '{"event":"transcription","text":"hello","isFinal":true}' } as MessageEvent;
+        channel.onmessage!(event);
+
+        expect(onMessage).toHaveBeenCalledWith({
+            text: '{"event":"transcription","text":"hello","isFinal":true}',
+        });
+    });
+
+    it('decodes ArrayBuffer client_tool_call events and forwards them', async () => {
+        const { BrowserDataChannelAdapter } = await import('../adapters/browser/BrowserDataChannelAdapter');
+        const channel = makeMockRTCDataChannel();
+        const onMessage = vi.fn();
+
+        const adapter = new BrowserDataChannelAdapter();
+        adapter.bind(channel as unknown as RTCDataChannel, {
+            onOpen: vi.fn(),
+            onMessage,
+            onError: vi.fn(),
+        });
+
+        const payload = JSON.stringify({ event: 'client_tool_call', tool_call_id: 'tc_1' });
+        const encoder = new TextEncoder();
+        const buffer = encoder.encode(payload).buffer;
+
+        channel.onmessage!({ data: buffer } as MessageEvent);
+
+        expect(onMessage).toHaveBeenCalledWith({ text: payload });
+    });
+
+    it('drops non-client_tool_call binary frames', async () => {
+        const { BrowserDataChannelAdapter } = await import('../adapters/browser/BrowserDataChannelAdapter');
+        const channel = makeMockRTCDataChannel();
+        const onMessage = vi.fn();
+
+        const adapter = new BrowserDataChannelAdapter();
+        adapter.bind(channel as unknown as RTCDataChannel, {
+            onOpen: vi.fn(),
+            onMessage,
+            onError: vi.fn(),
+        });
+
+        const payload = JSON.stringify({ event: 'clearAudio' });
+        const encoder = new TextEncoder();
+        const buffer = encoder.encode(payload).buffer;
+
+        channel.onmessage!({ data: buffer } as MessageEvent);
+
+        expect(onMessage).not.toHaveBeenCalled();
+    });
+
+    it('controller.isOpen() reflects channel state', async () => {
+        const { BrowserDataChannelAdapter } = await import('../adapters/browser/BrowserDataChannelAdapter');
+        const channel = makeMockRTCDataChannel();
+        channel.readyState = 'open';
+
+        const adapter = new BrowserDataChannelAdapter();
+        const controller = adapter.bind(channel as unknown as RTCDataChannel, {
+            onOpen: vi.fn(),
+            onMessage: vi.fn(),
+            onError: vi.fn(),
+        });
+
+        expect(controller.isOpen()).toBe(true);
+
+        channel.readyState = 'closed';
+        expect(controller.isOpen()).toBe(false);
+    });
+
+    it('controller.send() only fires when channel is open', async () => {
+        const { BrowserDataChannelAdapter } = await import('../adapters/browser/BrowserDataChannelAdapter');
+        const channel = makeMockRTCDataChannel();
+
+        const adapter = new BrowserDataChannelAdapter();
+        const controller = adapter.bind(channel as unknown as RTCDataChannel, {
+            onOpen: vi.fn(),
+            onMessage: vi.fn(),
+            onError: vi.fn(),
+        });
+
+        channel.readyState = 'open';
+        controller.send('{"event":"test"}');
+        expect(channel.send).toHaveBeenCalledWith('{"event":"test"}');
+
+        vi.clearAllMocks();
+        channel.readyState = 'closed';
+        controller.send('{"event":"test"}');
+        expect(channel.send).not.toHaveBeenCalled();
+    });
+});
+
+// ─── 3. RNDataChannelAdapter ──────────────────────────────────────────────────
+
+describe('RNDataChannelAdapter', () => {
+    it('forwards string messages', async () => {
+        const { RNDataChannelAdapter } = await import('../adapters/react-native/RNDataChannelAdapter');
+        const channel = makeMockRTCDataChannel();
+        const onMessage = vi.fn();
+
+        const adapter = new RNDataChannelAdapter();
+        adapter.bind(channel as unknown as RTCDataChannel, {
+            onOpen: vi.fn(),
+            onMessage,
+            onError: vi.fn(),
+        });
+
+        channel.onmessage!({ data: '{"event":"transcription","text":"hi","isFinal":false}' } as MessageEvent);
+        expect(onMessage).toHaveBeenCalledWith({
+            text: '{"event":"transcription","text":"hi","isFinal":false}',
+        });
+    });
+
+    it('decodes ArrayBuffer client_tool_call without global TextDecoder', async () => {
+        const original = globalThis.TextDecoder;
+        // @ts-expect-error simulate Hermes without TextDecoder
+        delete globalThis.TextDecoder;
+
+        const { RNDataChannelAdapter } = await import('../adapters/react-native/RNDataChannelAdapter');
+        const channel = makeMockRTCDataChannel();
+        const onMessage = vi.fn();
+
+        const adapter = new RNDataChannelAdapter();
+        adapter.bind(channel as unknown as RTCDataChannel, {
+            onOpen: vi.fn(),
+            onMessage,
+            onError: vi.fn(),
+        });
+
+        const payload = JSON.stringify({
+            event: 'client_tool_call',
+            tool_call: {
+                tool_call_id: 'tc_rn_1',
+                name: 'display_booking_calendar',
+                arguments: { user_id: '113', reason: 'book' },
+            },
+        });
+        const encoder = new TextEncoder();
+        const buffer = encoder.encode(payload).buffer;
+
+        channel.onmessage!({ data: buffer } as MessageEvent);
+
+        expect(onMessage).toHaveBeenCalledWith({ text: payload });
+
+        if (original) {
+            globalThis.TextDecoder = original;
+        }
+    });
+});
+
+// ─── 4. Runtime capabilities ──────────────────────────────────────────────────
+
+describe('Runtime capabilities', () => {
+    it('browserCapabilities has supportsAudioEndedEvent=true', async () => {
+        const { browserCapabilities } = await import('../runtime/browserRuntime');
+        expect(browserCapabilities.supportsAudioEndedEvent).toBe(true);
+        expect(browserCapabilities.supportsDom).toBeDefined();
+    });
+
+    it('reactNativeCapabilities has all flags false', async () => {
+        const { reactNativeCapabilities } = await import('../runtime/reactNativeRuntime');
+        expect(reactNativeCapabilities.supportsAudioEndedEvent).toBe(false);
+        expect(reactNativeCapabilities.supportsScreenShare).toBe(false);
+        expect(reactNativeCapabilities.supportsDom).toBe(false);
+        expect(reactNativeCapabilities.supportsHtmlAudio).toBe(false);
+        expect(reactNativeCapabilities.supportsCustomElements).toBe(false);
+        expect(reactNativeCapabilities.supportsLocalStorage).toBe(false);
+        expect(reactNativeCapabilities.supportsBroadcastChannel).toBe(false);
+    });
+
+    it('reactNativeRuntime has correct protocol metadata', async () => {
+        const { reactNativeRuntime } = await import('../runtime/reactNativeRuntime');
+        expect(reactNativeRuntime.callType).toBe('web');
+        expect(reactNativeRuntime.runtimeName).toBe('react-native');
+        expect(reactNativeRuntime.callIdPrefix).toBe('rn_');
+    });
+
+    it('browserRuntime has correct protocol metadata', async () => {
+        const { browserRuntime } = await import('../runtime/browserRuntime');
+        expect(browserRuntime.callType).toBe('web');
+        expect(browserRuntime.runtimeName).toBe('browser');
+        expect(browserRuntime.callIdPrefix).toBe('web_');
+    });
+});
+
+// ─── 5. DataChannel protocol — JSON parsing ───────────────────────────────────
+
+describe('DataChannel protocol parsing', () => {
+    it('correctly identifies client_tool_call events', () => {
+        const payload = {
+            event: 'client_tool_call',
+            tool_call_id: 'tc_abc123',
+            tool_call: {
+                tool_call_id: 'tc_abc123',
+                name: 'show_product',
+                arguments: { product_id: '42' },
+                execution_mode: 'blocking',
+            },
+        };
+        const text = JSON.stringify(payload);
+        const parsed = JSON.parse(text) as { event: string };
+        expect(parsed.event).toBe('client_tool_call');
+    });
+
+    it('distinguishes transcription events with isFinal flag', () => {
+        const interim = JSON.parse('{"event":"transcription","text":"hello","isFinal":false}') as {
+            event: string; text: string; isFinal: boolean;
+        };
+        const final = JSON.parse('{"event":"transcription","text":"hello world","isFinal":true}') as {
+            event: string; text: string; isFinal: boolean;
+        };
+        expect(interim.isFinal).toBe(false);
+        expect(final.isFinal).toBe(true);
+    });
+});
+
+// ─── 6. ICE server propagation ────────────────────────────────────────────────
+
+describe('ICE server propagation', () => {
+    it('WebRTCClient stores provided iceServers', async () => {
+        // Just test config storage — no actual RTCPeerConnection created here
+        const customServers = [{ urls: 'stun:custom.example.com:3478' }];
+
+        const { WebRTCClient } = await import('../core/WebRTCClient');
+
+        // We can't easily test the private iceServers field without a real connect()
+        // but we can verify the config is accepted without throwing
+        expect(() => {
+            new WebRTCClient({
+                agentId: 'test-agent',
+                serverUrl: 'https://worker.example.com',
+                iceServers: customServers as RTCIceServer[],
+            });
+        }).not.toThrow();
+    });
+
+    it('WebRTCClient throws when neither serverUrl nor apiKey is provided', async () => {
+        const { WebRTCClient } = await import('../core/WebRTCClient');
+        expect(() => {
+            new WebRTCClient({ agentId: 'test-agent' } as never);
+        }).toThrow('[VaniraSDK] Provide either serverUrl or apiKey');
+    });
+
+    it('WebRTCClient throws when agentId is missing', async () => {
+        const { WebRTCClient } = await import('../core/WebRTCClient');
+        expect(() => {
+            new WebRTCClient({ serverUrl: 'https://worker.example.com' } as never);
+        }).toThrow('[VaniraSDK] agentId is required');
+    });
+});
+
+// ─── 7. createCall runtime metadata ──────────────────────────────────────────
+
+describe('createCall runtime metadata', () => {
+    it('sends correct type and runtime for browser', async () => {
+        const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({ call_id: 'call_1', worker_url: 'https://w.example.com' }),
+        } as Response).mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({ answer: { type: 'answer', sdp: '' } }),
+        } as Response);
+
+        // Mock RTCPeerConnection for the connect() call
+        const mockPc = makeMockRTCPeerConnection();
+        (globalThis as unknown as Record<string, unknown>).RTCPeerConnection = vi.fn(() => mockPc);
+
+        const mockGetUserMedia = vi.fn(() => Promise.resolve({
+            getTracks: () => [{ kind: 'audio', stop: vi.fn() }],
+        } as unknown as MediaStream));
+        Object.defineProperty(globalThis, 'navigator', {
+            value: { mediaDevices: { getUserMedia: mockGetUserMedia } },
+            configurable: true,
+        });
+
+        const { WebRTCClient } = await import('../core/WebRTCClient');
+        const { browserRuntime } = await import('../runtime/browserRuntime');
+
+        const client = new WebRTCClient({
+            agentId: 'agent_1',
+            apiKey: 'sk_live_test',
+            runtime: browserRuntime,
+        });
+
+        // Only check the first fetch (createCall) — stop before connect succeeds
+        try {
+            await client.createCall();
+        } catch {
+            // connect() may fail due to mock limitations, ignore
+        }
+
+        const firstCallArgs = fetchSpy.mock.calls[0];
+        expect(firstCallArgs[0]).toContain('/calls/create');
+        const body = JSON.parse(firstCallArgs[1]?.body as string);
+        expect(body.type).toBe('web');
+        expect(body.runtime).toBe('browser');
+
+        vi.restoreAllMocks();
+    });
+
+    it('sends type=web runtime=react-native for RN runtime', async () => {
+        const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({ call_id: 'call_rn_1', worker_url: 'https://w.example.com' }),
+        } as Response).mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({ answer: { type: 'answer', sdp: '' } }),
+        } as Response);
+
+        const mockPc = makeMockRTCPeerConnection();
+        (globalThis as unknown as Record<string, unknown>).RTCPeerConnection = vi.fn(() => mockPc);
+
+        const { WebRTCClient } = await import('../core/WebRTCClient');
+        const { reactNativeRuntime } = await import('../runtime/reactNativeRuntime');
+
+        const client = new WebRTCClient({
+            agentId: 'agent_1',
+            apiKey: 'sk_live_test',
+            runtime: reactNativeRuntime,
+        });
+
+        try {
+            await client.createCall();
+        } catch {
+            // ignore connect() failures in test environment
+        }
+
+        const firstCallArgs = fetchSpy.mock.calls[0];
+        const body = JSON.parse(firstCallArgs[1]?.body as string);
+        expect(body.type).toBe('web');
+        expect(body.runtime).toBe('react-native');
+
+        vi.restoreAllMocks();
+    });
+});
+
+// ─── 8. playedStream capability flag ─────────────────────────────────────────
+
+describe('playedStream capability flag', () => {
+    it('supportsAudioEndedEvent=false skips playedStream registration', async () => {
+        const { reactNativeCapabilities } = await import('../runtime/reactNativeRuntime');
+        // The flag itself is what the WebRTCClient reads to decide whether to
+        // register onEnded.  Verify the RN runtime correctly signals this.
+        expect(reactNativeCapabilities.supportsAudioEndedEvent).toBe(false);
+    });
+
+    it('supportsAudioEndedEvent=true registers onEnded on browser', async () => {
+        const { browserCapabilities } = await import('../runtime/browserRuntime');
+        expect(browserCapabilities.supportsAudioEndedEvent).toBe(true);
+    });
+
+    it('sends playedStream after final transcription on RN runtime (not on mark)', async () => {
+        vi.useFakeTimers();
+        const { reactNativeRuntime } = await import('../runtime/reactNativeRuntime');
+        const { WebRTCClient } = await import('../core/WebRTCClient');
+
+        const client = new WebRTCClient({
+            agentId: 'agent_1',
+            serverUrl: 'https://worker.example.com',
+            runtime: reactNativeRuntime,
+        });
+
+        const send = vi.fn();
+        Object.assign(client, {
+            dcController: { isOpen: () => true, send },
+        });
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (client as any).handleControlEvent({ event: 'mark', name: 'tts_end' });
+        vi.advanceTimersByTime(2000);
+        expect(send).not.toHaveBeenCalled();
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (client as any).handleControlEvent({
+            event: 'transcription',
+            text: 'Hello',
+            isFinal: true,
+        });
+        vi.advanceTimersByTime(1800);
+
+        expect(send).toHaveBeenCalledWith(JSON.stringify({ event: 'playedStream' }));
+        vi.useRealTimers();
+    });
+});

package/src/__tests__/httpResponse.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+import { readResponseJson } from '../core/httpResponse';
+
+function mockResponse(status: number, body: string): Response {
+    return {
+        status,
+        text: async () => body,
+    } as Response;
+}
+
+describe('readResponseJson', () => {
+    it('parses valid JSON', async () => {
+        const data = await readResponseJson(
+            mockResponse(200, '{"answer":{"type":"answer","sdp":"v=0"}}'),
+            'test',
+        );
+        expect(data.answer).toBeDefined();
+    });
+
+    it('throws with body snippet when response is plain text "error"', async () => {
+        await expect(
+            readResponseJson(mockResponse(502, 'error'), 'WebRTC offer exchange'),
+        ).rejects.toThrow(/expected JSON but got.*error/);
+    });
+});

package/src/__tests__/mocks/react-native-incall-manager.ts

@@ -0,0 +1,8 @@
+const InCallManager = {
+  start: () => {},
+  stop: () => {},
+  setForceSpeakerphoneOn: () => {},
+  setSpeakerphoneOn: () => {},
+};
+
+export default InCallManager;

package/src/__tests__/mocks/react-native-permissions.ts

@@ -0,0 +1,15 @@
+export const PERMISSIONS = {
+  IOS: {PHOTO_LIBRARY: 'ios.permission.PHOTO_LIBRARY'},
+  ANDROID: {
+    READ_MEDIA_IMAGES: 'android.permission.READ_MEDIA_IMAGES',
+    READ_EXTERNAL_STORAGE: 'android.permission.READ_EXTERNAL_STORAGE',
+  },
+};
+
+export const RESULTS = {
+  GRANTED: 'granted',
+  LIMITED: 'limited',
+  DENIED: 'denied',
+};
+
+export const request = async () => RESULTS.GRANTED;

package/src/__tests__/mocks/react-native-webrtc.ts

@@ -0,0 +1,6 @@
+export const RTCPeerConnection = class {};
+export const RTCSessionDescription = class {};
+export const RTCIceCandidate = class {};
+export const mediaDevices = {getUserMedia: async () => ({})};
+export const registerGlobals = () => {};
+export const RTCView = 'RTCView';

package/src/__tests__/mocks/react-native.ts

@@ -0,0 +1,28 @@
+export const NativeModules = {
+  InCallManager: {},
+};
+
+export const Platform = {
+  OS: 'ios' as const,
+  Version: '17.0',
+  select<T>(specifics: {ios?: T; android?: T; default?: T}): T | undefined {
+    return specifics.ios ?? specifics.default;
+  },
+};
+
+export const Linking = {
+  openURL: async () => {},
+  canOpenURL: async () => true,
+};
+
+export const Modal = 'Modal';
+export const View = 'View';
+export const Text = 'Text';
+export const Pressable = 'Pressable';
+export const StyleSheet = {
+  create<T extends Record<string, unknown>>(styles: T): T {
+    return styles;
+  },
+};
+export const ActivityIndicator = 'ActivityIndicator';
+export const Alert = {alert: () => {}};