@qafka/react-native 2.0.0

package/dist/services/ConversationManager.d.ts

@@ -0,0 +1,43 @@
+import { ChatMessage } from '../types/chat';
+/**
+ * Conversation Manager
+ * Handles conversation history and session management
+ */
+export declare class ConversationManager {
+    private sessionId;
+    private messages;
+    private maxMessages;
+    constructor(sessionId?: string);
+    /**
+    * Initialize manager
+    */
+    initialize(): Promise<void>;
+    /**
+    * Add message to conversation
+    */
+    addMessage(message: ChatMessage): void;
+    /**
+    * Get conversation history
+    */
+    getHistory(limit?: number): ChatMessage[];
+    /**
+    * Get session ID
+    */
+    getSessionId(): string;
+    /**
+    * Clear conversation
+    */
+    clear(): Promise<void>;
+    /**
+    * Load from storage
+    */
+    private loadFromStorage;
+    /**
+    * Save to storage
+    */
+    private saveToStorage;
+    /**
+    * Generate session ID
+    */
+    private generateSessionId;
+}

package/dist/services/ConversationManager.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationManager = void 0;
+const storage_1 = require("./storage");
+const constants_1 = require("../constants");
+/**
+ * Conversation Manager
+ * Handles conversation history and session management
+ */
+class ConversationManager {
+    sessionId;
+    messages = [];
+    maxMessages = 50;
+    constructor(sessionId) {
+        this.sessionId = sessionId || this.generateSessionId();
+    }
+    /**
+    * Initialize manager
+    */
+    async initialize() {
+        await this.loadFromStorage();
+    }
+    /**
+    * Add message to conversation
+    */
+    addMessage(message) {
+        this.messages.push(message);
+        // Keep only last N messages
+        if (this.messages.length > this.maxMessages) {
+            this.messages = this.messages.slice(-this.maxMessages);
+        }
+        this.saveToStorage();
+    }
+    /**
+    * Get conversation history
+    */
+    getHistory(limit) {
+        if (limit) {
+            return this.messages.slice(-limit);
+        }
+        return [...this.messages];
+    }
+    /**
+    * Get session ID
+    */
+    getSessionId() {
+        return this.sessionId;
+    }
+    /**
+    * Clear conversation
+    */
+    async clear() {
+        this.messages = [];
+        this.sessionId = this.generateSessionId();
+        await storage_1.storage.removeItem(constants_1.STORAGE_KEYS.CONVERSATION_HISTORY);
+    }
+    /**
+    * Load from storage
+    */
+    async loadFromStorage() {
+        try {
+            const stored = await storage_1.storage.getItem(constants_1.STORAGE_KEYS.CONVERSATION_HISTORY);
+            if (stored) {
+                const data = JSON.parse(stored);
+                this.messages = data.messages || [];
+                this.sessionId = data.sessionId || this.sessionId;
+            }
+        }
+        catch {
+            // Silent error handling
+        }
+    }
+    /**
+    * Save to storage
+    */
+    async saveToStorage() {
+        try {
+            const data = {
+                sessionId: this.sessionId,
+                messages: this.messages,
+                updatedAt: new Date().toISOString(),
+            };
+            await storage_1.storage.setItem(constants_1.STORAGE_KEYS.CONVERSATION_HISTORY, JSON.stringify(data));
+        }
+        catch {
+            // Silent error handling
+        }
+    }
+    /**
+    * Generate session ID
+    */
+    generateSessionId() {
+        return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+}
+exports.ConversationManager = ConversationManager;

package/dist/services/NavigationHandler.d.ts

@@ -0,0 +1,29 @@
+import { NavigationContainerRef } from '@react-navigation/native';
+/**
+ * Navigation Handler
+ * Handles navigation based on AI suggestions
+ */
+export declare class NavigationHandler {
+    private navigationRef;
+    constructor(navigationRef?: NavigationContainerRef<any>);
+    /**
+    * Set navigation reference
+    */
+    setNavigationRef(ref: NavigationContainerRef<any>): void;
+    /**
+    * Navigate to screen
+    */
+    navigate(screenName: string, params?: any): void;
+    /**
+    * Go back
+    */
+    goBack(): void;
+    /**
+    * Get current route name
+    */
+    getCurrentRoute(): string | undefined;
+    /**
+    * Reset navigation
+    */
+    reset(routeName: string, params?: any): void;
+}

package/dist/services/NavigationHandler.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NavigationHandler = void 0;
+/**
+ * Navigation Handler
+ * Handles navigation based on AI suggestions
+ */
+class NavigationHandler {
+    navigationRef;
+    constructor(navigationRef) {
+        this.navigationRef = navigationRef || null;
+    }
+    /**
+    * Set navigation reference
+    */
+    setNavigationRef(ref) {
+        this.navigationRef = ref;
+    }
+    /**
+    * Navigate to screen
+    */
+    navigate(screenName, params) {
+        if (!this.navigationRef) {
+            return;
+        }
+        if (!this.navigationRef.isReady()) {
+            return;
+        }
+        try {
+            // @ts-ignore - navigate accepts screen name
+            this.navigationRef.navigate(screenName, params);
+        }
+        catch {
+            // Navigation error silently ignored
+        }
+    }
+    /**
+    * Go back
+    */
+    goBack() {
+        if (!this.navigationRef) {
+            return;
+        }
+        if (this.navigationRef.canGoBack()) {
+            this.navigationRef.goBack();
+        }
+    }
+    /**
+    * Get current route name
+    */
+    getCurrentRoute() {
+        if (!this.navigationRef || !this.navigationRef.isReady()) {
+            return undefined;
+        }
+        return this.navigationRef.getCurrentRoute()?.name;
+    }
+    /**
+    * Reset navigation
+    */
+    reset(routeName, params) {
+        if (!this.navigationRef || !this.navigationRef.isReady()) {
+            return;
+        }
+        this.navigationRef.reset({
+            index: 0,
+            routes: [{ name: routeName, params }],
+        });
+    }
+}
+exports.NavigationHandler = NavigationHandler;

package/dist/services/RealtimeService.d.ts

@@ -0,0 +1,83 @@
+export type RealtimeEvent = {
+    type: 'session.ready';
+} | {
+    type: 'session.closed';
+    reason: string;
+} | {
+    type: 'response.audio.delta';
+    delta: string;
+} | {
+    type: 'response.text.delta';
+    delta: string;
+} | {
+    type: 'response.done';
+} | {
+    type: 'conversation.item.input_audio_transcription.completed';
+    transcript: string;
+} | {
+    type: 'error';
+    message: string;
+} | {
+    type: 'tool_status';
+    toolCallId: string;
+    toolKey: string;
+    loadingMessage: string;
+} | {
+    type: 'tool_suggested';
+    toolCallId: string;
+    tools: any[];
+    conversationId: string;
+    messageId?: string;
+} | {
+    type: 'tool_done';
+    toolCallId: string;
+};
+export type RealtimeEventHandler = (event: RealtimeEvent) => void;
+export declare class RealtimeService {
+    private apiUrl;
+    private apiKey;
+    private ws;
+    private audioUnsubscribe;
+    private eventHandler;
+    private audioChunksSent;
+    private sessionTokenGetter;
+    private appVersion;
+    constructor(apiUrl: string, apiKey: string);
+    setSessionTokenGetter(fn: () => Promise<string | null>): void;
+    connect(onEvent: RealtimeEventHandler, options?: {
+        userContext?: Record<string, any>;
+        contextDescription?: string;
+        endUserId?: string;
+        endUserData?: Record<string, unknown>;
+    }): Promise<void>;
+    private audioDeltasReceived;
+    private handleEvent;
+    private attachAudioListener;
+    private detachAudioListener;
+    private startAudioPipeline;
+    /**
+    * Fully stop the native audio engine (capture + playback). Use when leaving
+    * voice mode entirely (e.g. scrolling back to chat page). NOT for tool-flow
+    * pauses — that breaks the AI's turn-2 audio playback because iOS
+    * AVAudioEngine unifies capture + playback in one engine instance.
+    */
+    pauseMic(): Promise<void>;
+    resumeMic(): Promise<void>;
+    /**
+    * Stop forwarding mic audio to the server WHILE keeping the native audio
+    * engine running so the AI's turn-2 audio playback continues. Use during
+    * tool flows where the user shouldn't interrupt but the AI may still speak.
+    */
+    muteMic(): void;
+    unmuteMic(): void;
+    sendToolResult(payload: {
+        toolCallId: string;
+        toolName: string;
+        output: any;
+        ok: boolean;
+        error?: string;
+    }): void;
+    disconnect(): Promise<void>;
+    private cleanup;
+    get isConnected(): boolean;
+}

package/dist/services/RealtimeService.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealtimeService = void 0;
+const QafkaAudio_1 = require("../native/QafkaAudio");
+const QafkaAttestation_1 = require("../native/QafkaAttestation");
+class RealtimeService {
+    apiUrl;
+    apiKey;
+    ws = null;
+    audioUnsubscribe = null;
+    eventHandler = null;
+    audioChunksSent = 0;
+    sessionTokenGetter = null;
+    appVersion = null;
+    constructor(apiUrl, apiKey) {
+        this.apiUrl = apiUrl;
+        this.apiKey = apiKey;
+        const deviceInfo = (0, QafkaAttestation_1.getDeviceInfo)();
+        this.appVersion = deviceInfo.appVersion || null;
+    }
+    setSessionTokenGetter(fn) {
+        this.sessionTokenGetter = fn;
+    }
+    async connect(onEvent, options) {
+        this.eventHandler = onEvent;
+        // Force wss:// in production builds. If the host app supplies an http://
+        // apiUrl in a non-dev build, that's a misconfiguration we'd rather hard-
+        // fail (with a TLS handshake failure) than silently downgrade to a
+        // plaintext WebSocket vulnerable to MITM.
+        const isDev = typeof __DEV__ !== 'undefined' && __DEV__;
+        const wsUrl = this.apiUrl.replace(/^https?:/, (m) => (m === 'https:' ? 'wss:' : isDev ? 'ws:' : 'wss:'));
+        const params = new URLSearchParams();
+        if (options?.userContext && Object.keys(options.userContext).length > 0) {
+            params.set('context', JSON.stringify(options.userContext));
+        }
+        if (options?.contextDescription &&
+            options.contextDescription.trim().length > 0) {
+            params.set('contextDescription', options.contextDescription);
+        }
+        if (options?.endUserId && options.endUserId.trim().length > 0) {
+            params.set('endUserId', options.endUserId);
+        }
+        if (options?.endUserData &&
+            typeof options.endUserData === 'object' &&
+            Object.keys(options.endUserData).length > 0) {
+            params.set('endUserData', JSON.stringify(options.endUserData));
+        }
+        const qs = params.toString();
+        const fullUrl = `${wsUrl}/v1/realtime${qs ? `?${qs}` : ''}`;
+        // Start the audio engine FIRST so the player is ready to schedule buffers
+        // the instant the backend starts streaming audio. The realtime service can
+        // emit audio deltas before native startCapture finishes if we start it after
+        // the WebSocket — the first ~20 chunks would drop with "engine not running".
+        // Doing it in this order closes that race.
+        await this.startAudioPipeline();
+        // Resolve the device-attestation session token BEFORE opening the WS so
+        // that it is ready to ship in the first auth frame. The getter is async
+        // (it may need to refresh an expired token via native attestation).
+        const sessionToken = this.sessionTokenGetter
+            ? await this.sessionTokenGetter()
+            : null;
+        return new Promise((resolve, reject) => {
+            this.ws = new WebSocket(fullUrl);
+            this.ws.onopen = () => {
+                // Send auth as the first frame instead of leaking the API key in the
+                // URL (avoids exposure via access logs / proxy histories). Session
+                // token, when available, lets the server tie this socket to a
+                // device-attested session.
+                const authPayload = {
+                    type: 'auth',
+                    apiKey: this.apiKey,
+                };
+                if (sessionToken)
+                    authPayload.sessionToken = sessionToken;
+                if (this.appVersion)
+                    authPayload.appVersion = this.appVersion;
+                try {
+                    this.ws?.send(JSON.stringify(authPayload));
+                }
+                catch {
+                    // ignore — onerror/onclose will surface failures
+                }
+                resolve();
+            };
+            this.ws.onmessage = (event) => {
+                try {
+                    const data = JSON.parse(event.data);
+                    this.handleEvent(data);
+                }
+                catch {
+                    // Ignore malformed messages
+                }
+            };
+            this.ws.onerror = () => {
+                reject(new Error('WebSocket connection failed'));
+            };
+            this.ws.onclose = (event) => {
+                this.cleanup();
+                this.eventHandler?.({
+                    type: 'session.closed',
+                    reason: event.reason || 'CONNECTION_CLOSED',
+                });
+            };
+        });
+    }
+    audioDeltasReceived = 0;
+    handleEvent(event) {
+        if (event.type === 'response.audio.delta' && 'delta' in event) {
+            this.audioDeltasReceived++;
+            QafkaAudio_1.QafkaAudio.playAudioChunk(event.delta).catch(() => {
+                // playback errors are surfaced to the consumer via eventHandler
+            });
+        }
+        this.eventHandler?.(event);
+    }
+    attachAudioListener() {
+        if (this.audioUnsubscribe)
+            return; // already attached
+        this.audioUnsubscribe = QafkaAudio_1.QafkaAudio.onAudioData(({ audio }) => {
+            if (this.ws?.readyState === WebSocket.OPEN) {
+                this.ws.send(JSON.stringify({ type: 'input_audio_buffer.append', audio }));
+                this.audioChunksSent++;
+            }
+        });
+    }
+    detachAudioListener() {
+        this.audioUnsubscribe?.();
+        this.audioUnsubscribe = null;
+    }
+    async startAudioPipeline() {
+        try {
+            // Attach listener BEFORE startCapture so the native tap
+            // doesn't drop early buffers (hasListeners/listenerCount gate).
+            this.attachAudioListener();
+            await QafkaAudio_1.QafkaAudio.startCapture();
+        }
+        catch (error) {
+            this.eventHandler?.({
+                type: 'error',
+                message: `Mic capture failed: ${error}`,
+            });
+        }
+    }
+    /**
+    * Fully stop the native audio engine (capture + playback). Use when leaving
+    * voice mode entirely (e.g. scrolling back to chat page). NOT for tool-flow
+    * pauses — that breaks the AI's turn-2 audio playback because iOS
+    * AVAudioEngine unifies capture + playback in one engine instance.
+    */
+    async pauseMic() {
+        await QafkaAudio_1.QafkaAudio.stopCapture();
+        this.detachAudioListener();
+    }
+    async resumeMic() {
+        await this.startAudioPipeline();
+    }
+    /**
+    * Stop forwarding mic audio to the server WHILE keeping the native audio
+    * engine running so the AI's turn-2 audio playback continues. Use during
+    * tool flows where the user shouldn't interrupt but the AI may still speak.
+    */
+    muteMic() {
+        this.detachAudioListener();
+    }
+    unmuteMic() {
+        this.attachAudioListener();
+    }
+    sendToolResult(payload) {
+        if (this.ws?.readyState !== WebSocket.OPEN) {
+            return;
+        }
+        this.ws.send(JSON.stringify({
+            type: 'tool_result',
+            toolCallId: payload.toolCallId,
+            toolName: payload.toolName,
+            output: payload.output,
+            ok: payload.ok,
+            error: payload.error,
+        }));
+    }
+    async disconnect() {
+        await this.cleanup();
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.close();
+        }
+        this.ws = null;
+        this.audioChunksSent = 0;
+    }
+    async cleanup() {
+        this.audioUnsubscribe?.();
+        this.audioUnsubscribe = null;
+        try {
+            await QafkaAudio_1.QafkaAudio.stopCapture();
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+    get isConnected() {
+        return this.ws?.readyState === WebSocket.OPEN;
+    }
+}
+exports.RealtimeService = RealtimeService;

package/dist/services/storage.d.ts

@@ -0,0 +1,11 @@
+import { type QafkaStorage } from './storageCore';
+/**
+ * Singleton storage wrapper used throughout the SDK.
+ *
+ * - Backed by Keychain (iOS) / EncryptedSharedPreferences (Android) when the
+ * native QafkaStorage module is registered.
+ * - Falls back to in-memory Map (with a single console.warn) if the native
+ * module is missing — which should only happen if autolinking failed or the
+ * host app was not rebuilt after upgrading the SDK.
+ */
+export declare const storage: QafkaStorage;

package/dist/services/storage.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storage = void 0;
+const QafkaStorage_1 = require("../native/QafkaStorage");
+const storageCore_1 = require("./storageCore");
+/**
+ * Singleton storage wrapper used throughout the SDK.
+ *
+ * - Backed by Keychain (iOS) / EncryptedSharedPreferences (Android) when the
+ * native QafkaStorage module is registered.
+ * - Falls back to in-memory Map (with a single console.warn) if the native
+ * module is missing — which should only happen if autolinking failed or the
+ * host app was not rebuilt after upgrading the SDK.
+ */
+exports.storage = (0, storageCore_1.createStorage)((0, QafkaStorage_1.getNativeStorage)());

package/dist/services/storageCore.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Native storage contract. Mirrors AsyncStorage's surface for the methods
+ * this SDK actually uses (getItem / setItem / removeItem / multiRemove).
+ */
+export interface QafkaStorageNative {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    multiRemove(keys: string[]): Promise<void>;
+}
+export interface QafkaStorage {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    multiRemove(keys: string[]): Promise<void>;
+}
+export declare function createStorage(native: QafkaStorageNative | null): QafkaStorage;

package/dist/services/storageCore.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStorage = createStorage;
+const FALLBACK_WARNING = '[Qafka] Native QafkaStorage module not registered — falling back to ' +
+    'in-memory storage. Persistence will be lost when the app closes. ' +
+    'This usually means autolinking failed or the app was not rebuilt after ' +
+    'upgrading the SDK.';
+function createStorage(native) {
+    if (native) {
+        return {
+            getItem: (key) => native.getItem(key),
+            setItem: (key, value) => native.setItem(key, value),
+            removeItem: (key) => native.removeItem(key),
+            multiRemove: (keys) => native.multiRemove(keys),
+        };
+    }
+    const memory = new Map();
+    let warned = false;
+    const warnOnce = () => {
+        if (!warned) {
+            if (typeof __DEV__ !== 'undefined' && __DEV__) {
+                console.warn(FALLBACK_WARNING);
+            }
+            warned = true;
+        }
+    };
+    return {
+        async getItem(key) {
+            warnOnce();
+            return memory.has(key) ? memory.get(key) : null;
+        },
+        async setItem(key, value) {
+            warnOnce();
+            memory.set(key, value);
+        },
+        async removeItem(key) {
+            warnOnce();
+            memory.delete(key);
+        },
+        async multiRemove(keys) {
+            warnOnce();
+            for (const k of keys)
+                memory.delete(k);
+        },
+    };
+}

package/dist/themes/dark.d.ts

@@ -0,0 +1,5 @@
+import { Theme } from './types';
+/**
+ * Dark theme configuration
+ */
+export declare const darkTheme: Theme;