@vanira/sdk-react-native 0.0.2

package/src/adapters/react-native/rnUploadFile.ts

@@ -0,0 +1,76 @@
+/**
+ * React Native file descriptor for FormData uploads.
+ * RN FormData.append('file', { uri, type, name }) — not Blob/File.
+ */
+
+export type RNUploadFileDescriptor = {
+    uri: string;
+    type: string;
+    name: string;
+    size?: number;
+};
+
+export type UploadMediaInput = File | Blob | RNUploadFileDescriptor;
+
+const EXT_TO_MIME: Record<string, string> = {
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    png: 'image/png',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    bmp: 'image/bmp',
+    heic: 'image/jpeg',
+    heif: 'image/jpeg',
+    pdf: 'application/pdf',
+    txt: 'text/plain',
+    csv: 'text/csv',
+};
+
+const MIME_ALIASES: Record<string, string> = {
+    'image/jpg': 'image/jpeg',
+    'image/pjpeg': 'image/jpeg',
+    'text/comma-separated-values': 'text/csv',
+};
+
+export function normalizeUploadMimeForUpload(
+    file: UploadMediaInput,
+): string {
+    if (isRNUploadFileDescriptor(file)) {
+        const raw = file.type?.trim().toLowerCase() ?? '';
+        if (raw && raw in MIME_ALIASES) {
+            return MIME_ALIASES[raw];
+        }
+        if (raw && raw !== 'application/octet-stream') {
+            return raw;
+        }
+        const ext = file.name.split('.').pop()?.toLowerCase();
+        if (ext && ext in EXT_TO_MIME) {
+            return EXT_TO_MIME[ext];
+        }
+        return raw || 'application/octet-stream';
+    }
+    const raw = file.type?.trim().toLowerCase() ?? '';
+    return MIME_ALIASES[raw] ?? raw;
+}
+
+export function isRNUploadFileDescriptor(
+    file: unknown
+): file is RNUploadFileDescriptor {
+    return (
+        typeof file === 'object' &&
+        file !== null &&
+        'uri' in file &&
+        typeof (file as RNUploadFileDescriptor).uri === 'string'
+    );
+}
+
+export function uploadFileMimeType(file: UploadMediaInput): string {
+    return normalizeUploadMimeForUpload(file);
+}
+
+export function uploadFileByteSize(file: UploadMediaInput): number | undefined {
+    if (isRNUploadFileDescriptor(file)) {
+        return file.size;
+    }
+    return file.size;
+}

package/src/adapters/storage/BrowserDualStorageAdapter.ts

@@ -0,0 +1,71 @@
+import type { StorageAdapter } from './StorageAdapter';
+
+/**
+ * Browser storage adapter matching existing WebRTCClient dual-write semantics.
+ *
+ * Keys (unchanged): `vanira_prospect_id`, `vanira_latest_call_id`
+ *
+ * - getItem: sessionStorage first, then localStorage fallback
+ * - setItem: writes to both (each wrapped in try/catch)
+ * - removeItem: removes from both (each wrapped in try/catch)
+ */
+export class BrowserDualStorageAdapter implements StorageAdapter {
+    getItem(key: string): string | null {
+        try {
+            if (typeof sessionStorage !== 'undefined') {
+                const sessionValue = sessionStorage.getItem(key);
+                if (sessionValue !== null) {
+                    return sessionValue;
+                }
+            }
+        } catch {
+            // SecurityError, private mode, SSR — fall through to localStorage
+        }
+
+        try {
+            if (typeof localStorage !== 'undefined') {
+                return localStorage.getItem(key);
+            }
+        } catch {
+            // ignore
+        }
+
+        return null;
+    }
+
+    setItem(key: string, value: string): void {
+        try {
+            if (typeof sessionStorage !== 'undefined') {
+                sessionStorage.setItem(key, value);
+            }
+        } catch {
+            // ignore blocked / quota errors on sessionStorage
+        }
+
+        try {
+            if (typeof localStorage !== 'undefined') {
+                localStorage.setItem(key, value);
+            }
+        } catch {
+            // ignore blocked / quota errors on localStorage
+        }
+    }
+
+    removeItem(key: string): void {
+        try {
+            if (typeof sessionStorage !== 'undefined') {
+                sessionStorage.removeItem(key);
+            }
+        } catch {
+            // ignore
+        }
+
+        try {
+            if (typeof localStorage !== 'undefined') {
+                localStorage.removeItem(key);
+            }
+        } catch {
+            // ignore
+        }
+    }
+}

package/src/adapters/storage/MemoryStorageAdapter.ts

@@ -0,0 +1,50 @@
+import type { StorageAdapter } from './StorageAdapter';
+
+/**
+ * In-memory StorageAdapter for React Native default bundle, unit tests, and SSR.
+ *
+ * Data does not survive app restarts. In production (`NODE_ENV === 'production'`),
+ * setItem logs a one-time warning directing apps to inject a persistent store via
+ * `createSyncStorageAdapter()` or `config.storageAdapter`.
+ */
+export class MemoryStorageAdapter implements StorageAdapter {
+    private readonly store = new Map<string, string>();
+    private productionWarned = false;
+
+    getItem(key: string): string | null {
+        if (!this.store.has(key)) {
+            return null;
+        }
+        return this.store.get(key)!;
+    }
+
+    setItem(key: string, value: string): void {
+        this.warnProductionOnce();
+        this.store.set(key, value);
+    }
+
+    removeItem(key: string): void {
+        this.store.delete(key);
+    }
+
+    private warnProductionOnce(): void {
+        if (this.productionWarned) {
+            return;
+        }
+
+        const isProduction =
+            typeof process !== 'undefined' &&
+            process.env?.NODE_ENV === 'production';
+
+        if (!isProduction) {
+            return;
+        }
+
+        this.productionWarned = true;
+        console.warn(
+            '[VaniraSDK] MemoryStorageAdapter does not persist across app restarts. ' +
+            'Inject a persistent store via createSyncStorageAdapter() or config.storageAdapter ' +
+            'for production React Native apps.'
+        );
+    }
+}

package/src/adapters/storage/StorageAdapter.ts

@@ -0,0 +1,21 @@
+/**
+ * Synchronous key-value storage abstraction for session persistence.
+ *
+ * Used by WebRTCClient for `vanira_prospect_id` and `vanira_latest_call_id`
+ * when `sessionBehavior === 'continue'`.
+ *
+ * Platform defaults (via VaniraRuntime.storage):
+ *   Browser       — BrowserDualStorageAdapter (sessionStorage + localStorage)
+ *   React Native  — MemoryStorageAdapter (in-memory; inject persistent store for production)
+ */
+
+export interface StorageAdapter {
+    /** Returns the stored value, or null if the key is absent. */
+    getItem(key: string): string | null;
+
+    /** Persists a string value under key. */
+    setItem(key: string, value: string): void;
+
+    /** Removes key from storage. */
+    removeItem(key: string): void;
+}

package/src/adapters/storage/createSyncStorageAdapter.ts

@@ -0,0 +1,40 @@
+import type { StorageAdapter } from './StorageAdapter';
+
+/**
+ * Minimal synchronous backing store for createSyncStorageAdapter().
+ *
+ * Generic — no dependency on MMKV, AsyncStorage, or any specific RN package.
+ * Apps wire their own implementation, e.g. react-native-mmkv:
+ *
+ *   createSyncStorageAdapter({
+ *     getString: (key) => mmkv.getString(key),
+ *     setString: (key, value) => { mmkv.set(key, value); },
+ *     delete: (key) => { mmkv.delete(key); },
+ *   })
+ */
+export interface SyncStorageBackend {
+    getString(key: string): string | undefined;
+    setString(key: string, value: string): void;
+    /** When omitted, removeItem is a no-op on the backing store. */
+    delete?(key: string): void;
+}
+
+/**
+ * Wrap a generic sync key-value backend as a StorageAdapter.
+ */
+export function createSyncStorageAdapter(backend: SyncStorageBackend): StorageAdapter {
+    return {
+        getItem(key: string): string | null {
+            const value = backend.getString(key);
+            return value === undefined ? null : value;
+        },
+
+        setItem(key: string, value: string): void {
+            backend.setString(key, value);
+        },
+
+        removeItem(key: string): void {
+            backend.delete?.(key);
+        },
+    };
+}

package/src/adapters/storage/index.ts

@@ -0,0 +1,7 @@
+export type { StorageAdapter } from './StorageAdapter';
+export { BrowserDualStorageAdapter } from './BrowserDualStorageAdapter';
+export { MemoryStorageAdapter } from './MemoryStorageAdapter';
+export {
+    createSyncStorageAdapter,
+    type SyncStorageBackend,
+} from './createSyncStorageAdapter';

package/src/api/services/ChatService.ts

@@ -0,0 +1,304 @@
+export interface ChatMessage {
+    role: 'user' | 'assistant';
+    content: string;
+    widget?: {
+        type: 'carousel' | 'button_list';
+        data: any;
+    };
+}
+
+const HASURA_URL = 'https://coredb.travelr.club/v1/graphql';
+let CHAT_URL = 'https://inboxapi.vanira.io';
+
+export class ChatService {
+    static setChatUrl(url: string) {
+        CHAT_URL = url;
+    }
+
+    static async createChatProspect(prospectGroupId: string): Promise<string> {
+        const mutation = `
+        mutation CreateChatProspect($prospectGroupId: uuid!, $name: String!) {
+          insert_prospects_one(object: {prospect_group_id: $prospectGroupId, name: $name, source: WEBSITE_WIDGET}) {
+            id
+          }
+        }
+      `;
+
+        try {
+            const response = await fetch(HASURA_URL, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    query: mutation,
+                    variables: {
+                        prospectGroupId,
+                        name: `Widget Guest ${new Date().toLocaleString()}`
+                    }
+                }),
+            });
+
+            const data = await response.json();
+
+            if (data.errors) {
+                console.warn('[VaniraAI] Prospect creation failed, using anonymous ID', data.errors);
+                // Fallback Logic
+                return `anon_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+            }
+
+            return data.data?.insert_prospects_one?.id || `anon_${Date.now()}`;
+        } catch (error) {
+            console.error('[VaniraAI] Failed to create prospect:', error);
+            return `anon_${Date.now()}`;
+        }
+    }
+
+    // Calls the new Go bridge /widget/chat endpoint with an empty message to initialize the session and get the Welcome config + inbox_id
+    static async fetchWelcomeMessage(agentId: string, prospectId: string, widgetId?: string, _pkKey?: string): Promise<ChatMessage & { chatId?: string, conversationId?: string }> {
+        try {
+            const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+
+            const response = await fetch(`${CHAT_URL}/widget/chat`, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({
+                    agent_id: agentId,
+                    ...(widgetId ? { widget_id: widgetId } : {}),
+                    message: '',
+                    prospect_id: prospectId,
+                    stream: false
+                }),
+            });
+
+            if (!response.ok) throw new Error('Failed to fetch welcome message');
+
+            const data = await response.json();
+            let content = data.response || 'Hey! how can I help you ?';
+            let widget = undefined;
+            const chatId = data.chat_id || data.inbox_id; // Go bridge returns chat_id which is the inbox_id
+            const conversationId = data.conversation_id || null;
+
+            if (data.widget) {
+                widget = data.widget;
+                // content stays as plain text — widget field carries structured buttons/cards
+                // handleWelcomePayload already reads payload.widget for button chips
+            }
+
+            return { role: 'assistant', content, widget, chatId, conversationId };
+        } catch (error) {
+            console.error('[VaniraAI] Failed to fetch welcome message:', error);
+            // Graceful Degradation
+            return { role: 'assistant', content: 'Hey! how can I help you ?' };
+        }
+    }
+
+    static async sendChatMessage(
+        agentId: string,
+        prospectId: string,
+        message: string,
+        chatId: string | null,
+        onChunk: (text: string) => void,
+        onWidget: (widget: any) => void,
+        onDone: (newChatId: string | null, newConversationId: string | null) => void,
+        widgetId?: string,
+        _pkKey?: string
+    ): Promise<void> {
+        try {
+            const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+
+            const payload: any = {
+                agent_id: agentId,
+                message: message,
+                prospect_id: prospectId,
+                stream: true
+            };
+
+            if (chatId) payload.inbox_id = chatId;
+            if (widgetId) payload.widget_id = widgetId;
+
+            const response = await fetch(`${CHAT_URL}/widget/chat`, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(payload),
+            });
+
+            if (!response.ok) throw new Error('Chat request failed');
+
+            const reader = response.body?.getReader();
+            const decoder = new TextDecoder();
+            if (!reader) throw new Error('No reader');
+
+            let assistantContent = '';
+            let buffer = '';
+            let newChatId: string | null = null;
+            let newConversationId: string | null = null;
+
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+
+                for (const line of lines) {
+                    const trimmedLine = line.trim();
+                    if (!trimmedLine) continue;
+
+                    if (trimmedLine.startsWith('data: ')) {
+                        const data = trimmedLine.slice(6);
+                        if (data === '[DONE]') {
+                            onDone(newChatId, newConversationId);
+                            return;
+                        }
+                        try {
+                            const parsed = JSON.parse(data);
+                            if (parsed.type === 'metadata') {
+                                // Go bridge sends inbox_id (not chat_id) in metadata — read both
+                                if (parsed.chat_id || parsed.inbox_id) newChatId = parsed.chat_id || parsed.inbox_id;
+                                if (parsed.conversation_id) newConversationId = parsed.conversation_id;
+                                continue;
+                            }
+                            const content = parsed.choices?.[0]?.delta?.content;
+                            if (content) {
+                                assistantContent += content;
+                                onChunk(assistantContent);
+                            }
+                            if (parsed.widget) {
+                                onWidget(parsed.widget);
+                            }
+                            if (parsed.chat_id && !newChatId) {
+                                newChatId = parsed.chat_id;
+                            }
+                            if (parsed.conversation_id && !newConversationId) {
+                                newConversationId = parsed.conversation_id;
+                            }
+                        } catch (e) { }
+                    }
+                }
+            }
+
+            onDone(newChatId, newConversationId);
+        } catch (error) {
+            console.error('[VaniraAI] Chat error:', error);
+            onChunk('Sorry, I encountered an error. Please try again.');
+            onDone(null, null);
+        }
+    }
+    static listenForAdminReplies(inboxId: string, sender: string, onMessage: (content: string) => void): { close: () => void } {
+        const url = `${CHAT_URL}/inbox/stream?inbox_id=${inboxId}&sender=${encodeURIComponent(sender)}`;
+        let es: EventSource | null = null;
+        let reconnectAttempts = 0;
+        let isClosed = false;
+
+        const connect = () => {
+            if (isClosed) return;
+
+            es = new EventSource(url);
+            console.log(`[VaniraAI] Subscribed to SSE EventSource at ${es.url}`);
+
+            es.onopen = () => {
+                console.log("[VaniraAI] SSE connection opened successfully.");
+                reconnectAttempts = 0; // Reset backoff on success
+            };
+
+            es.onmessage = (event) => {
+                console.log("[VaniraAI] 📡 Raw SSE Event triggered:", event.data);
+                try {
+                    const data = JSON.parse(event.data);
+                    console.log("[VaniraAI] SSE stream JSON parsed:", data);
+
+                    const isOutgoing = data.direction === 'outgoing';
+                    const hasContent = !!data.content;
+                    const isNotAI = data.source !== 'ai';
+
+                    if (isOutgoing && hasContent && isNotAI) {
+                        console.log("[VaniraAI] 🎯 Displaying admin message in chat UI:", data.content);
+                        onMessage(data.content);
+                    }
+                } catch (e) {
+                    console.error('[VaniraAI] SSE parse error', e);
+                }
+            };
+
+            es.onerror = (err) => {
+                console.error('[VaniraAI] SSE connection error or disconnect', err);
+                if (es) {
+                    es.close();
+                    es = null;
+                }
+
+                if (isClosed) return;
+
+                // Exponential backoff: 2s, 4s, 8s, 16s... max 30s
+                const delay = Math.min(2000 * Math.pow(2, reconnectAttempts), 30000);
+                console.log(`[VaniraAI] Reconnecting SSE in ${delay}ms (Attempt ${reconnectAttempts + 1})...`);
+                reconnectAttempts++;
+
+                setTimeout(connect, delay);
+            };
+        };
+
+        connect(); // Start initial connection
+
+        return {
+            close: () => {
+                isClosed = true;
+                if (es) {
+                    es.close();
+                    es = null;
+                    console.log("[VaniraAI] SSE connection manually closed.");
+                }
+            }
+        };
+    }
+
+    static async createCall(agentId: string, _clientId: string | null, prospectId: string | null, _widgetMode: string, pkKey?: string): Promise<{ callId: string, workerUrl: string }> {
+        try {
+            const BACKEND_URL = 'https://api.vanira.io';
+            const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+            if (pkKey) headers['X-API-Key'] = pkKey;
+
+            const response = await fetch(`${BACKEND_URL}/calls/create`, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({
+                    agent_id: agentId,
+                    prospect_id: prospectId || undefined,
+                    type: 'web',
+                }),
+            });
+
+            const data = await response.json();
+
+            if (!response.ok) {
+                throw new Error(`[VaniraAI] Call creation failed HTTP ${response.status}`);
+            }
+
+            if (!data.worker_url) {
+                throw new Error('[VaniraAI] Worker URL missing from response. Call cannot proceed.');
+            }
+
+            return {
+                callId: data.call_id || data.id || `web_${Date.now()}`,
+                workerUrl: data.worker_url // Pass the full authenticated URL
+            };
+        } catch (error) {
+            console.error('[VaniraAI] Failed to create call:', error);
+            throw error; // Re-throw to ensure caller knows it failed
+        }
+    }
+
+    static async resolveConversation(conversationId: string): Promise<void> {
+        try {
+            const response = await fetch(`${CHAT_URL}/inbox/conversations/resolve`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ conversation_id: conversationId }),
+            });
+            if (!response.ok) throw new Error('Failed to resolve conversation');
+        } catch (error) {
+            console.error('[VaniraAI] Failed to resolve conversation:', error);
+            throw error;
+        }
+    }
+}

package/src/api/services/ConfigService.ts

@@ -0,0 +1,33 @@
+import { WidgetConfig } from '../../types';
+
+const BACKEND_URL = 'https://api.vanira.io';
+
+export class ConfigService {
+    static async fetchWidgetConfig(widgetId: string, pkKey?: string): Promise<WidgetConfig> {
+        const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+        if (pkKey) headers['X-API-Key'] = pkKey;
+
+        try {
+            const response = await fetch(`${BACKEND_URL}/assistant/widget/${widgetId}/config`, {
+                method: 'GET',
+                headers,
+            });
+
+            if (!response.ok) {
+                throw new Error(`Widget config fetch failed: HTTP ${response.status}`);
+            }
+
+            const config = await response.json();
+
+            // Flatten agent.client into config.client to match WidgetConfig shape
+            if (config.agent?.client) {
+                config.client = config.agent.client;
+            }
+
+            return config as WidgetConfig;
+        } catch (error) {
+            console.error('[VaniraAI] Failed to fetch widget config:', error);
+            throw error;
+        }
+    }
+}

package/src/assets/icons.js

@@ -0,0 +1,35 @@
+export const icons = {
+  phone: `
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+      <path d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"/>
+    </svg>
+  `,
+  close: `
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+      <line x1="18" y1="6" x2="6" y2="18"/>
+      <line x1="6" y1="6" x2="18" y2="18"/>
+    </svg>
+  `,
+  mic: `
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+      <path d="M12 2a3 3 0 0 0-3 3v7a3 3 0 0 0 6 0V5a3 3 0 0 0-3-3z"/>
+      <path d="M19 10v2a7 7 0 0 1-14 0v-2"/>
+      <line x1="12" y1="19" x2="12" y2="22"/>
+    </svg>
+  `,
+  micOff: `
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+      <line x1="1" y1="1" x2="23" y2="23"/>
+      <path d="M9 9v3a3 3 0 0 0 5.12 2.12M15 9.34V4a3 3 0 0 0-5.94-.6"/>
+      <path d="M17 16.95A7 7 0 0 1 5 12v-2m14 0v2a7 7 0 0 1-.11 1.23"/>
+      <line x1="12" y1="19" x2="12" y2="23"/>
+    </svg>
+  `,
+  waves: `
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+      <path d="M2 6c.6.5 1.2 1 2.5 1C7 7 7 5 9.5 5c2.6 0 2.4 2 5 2 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1"/>
+      <path d="M2 12c.6.5 1.2 1 2.5 1 2.5 0 2.5-2 5-2 2.6 0 2.4 2 5 2 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1"/>
+      <path d="M2 18c.6.5 1.2 1 2.5 1 2.5 0 2.5-2 5-2 2.6 0 2.4 2 5 2 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1"/>
+    </svg>
+  `
+};